Sprite 1984 - 1993/Sprite 1984 - 1993.iso/src/cmds/cc/g++-dist/ChangeLog89

Text File | 1990-01-07 | 139.7 KB | 3,582 lines

Sun Dec 31 10:47:51 1989    (tiemann at calvin)

    * cplus-cvt.c (build_up_reference): Take multiple inheritance into
    account in all (instead of just some) cases.  Take virtual
    baseclasses into account in all (instead of no) cases.

    * cplus-init.c (build_vbase_delete): Convert ADDR before calling
    destructr.  Otherwise privately derived baseclasses will give
    problems.

    * cplus-init.c (expand_aggr_init_1): Distinguish case where
    initializer list fails because virtual baseclass lacks default
    initializer and other bad argument lists.

Sat Dec 30 13:09:43 1989    (tiemann at calvin)

    * cplus-tree.h (lang_type): Added bit for MARKED6.  Used to use
    MARKED3 to mean `base class initialized', but that conflicts with
    use meaning `virtual baseclass processed' in cplus-search.c.
    * cplus-init.c (finish_base_init): Use _MARKED6 instead of
    _MARKED3 to indicate a baseclass has been initialized.

    * cplus-init.c (expand_aggr_init_1): If TYPE_HAS_CONSTRUCTOR(TYPE)
    but no constructor takes the initializer, and there is no X(X&)
    constructor, generate code for X(X&) constructor by hand.

    * cplus-typeck.c (build_modify_expr_1): Substantially simplified
    using assumption that LHS and RHS are type-compatible as a
    consequence of being elements of isomorphic structures.

    * cplus-init.c (expand_aggr_init): If EXP is initialized from
    an object of its same type, and EXP does not have an X(X&)
    constructor, have build_modify_expr do the work.

Fri Dec 29 00:29:45 1989    (tiemann at calvin)

    * cplus-class.c (finish_struct): Don't build default functions by
    default.  Instead, rely on compiler doing the Right Thing when
    handling INIT_EXPR and MODIFY_EXPR.

    * cplus-typeck.c (build_modify_expr): Don't copy virtual function
    table fields or virtual baseclass fields when performing
    memberwise copying.
    Instead, split `build_modify_expr' into two functions, a recursive
    form `build_modify_expr_1' which doesn't do any copying for
    virtual baseclasses, and a non-recursive form `build_modify_expr',
    which does handle these at top level.

Thu Dec 28 12:37:37 1989    (tiemann at calvin)

    * cplus-decl.c (build_default_constructor): Typo--used
    DECL_VIRTUAL_P (...) when VFIELD_NAME_P (DECL_NAME (...)) was
    meant.  Also, take into account fact that second arg might be "in
    charge" arg.

    * cplus-class.c (finish_base_struct): Move setting of
    TYPE_USES_VIRTUAL_BASECLASSES from here...
    * cplus-decl.c (xref_tag): ...to here.  Needed because
    constructors for virtual baseclasses now need new type signatures.

    * cplus-decl2.c (grokclassfn): Rewrote code that inserts
    parameters so that SOS will work with virtual baseclasses.
    @@ But rest of SOS code must be changed to deal with this.

    * cplus-init.c (expand_aggr_vbase_init): Changed interface.  Last
    arg is no longer FUNCTION_DECL, rather, it is the list of
    initializations that the constructor must perform (if in charge).
    All virtual baseclasses, whether they need constructors or not,
    will be initialized one way or another.

    * cplus-decl.c (finish_function): Don't do special things for
    constructors with virtual baseclasses.  Leave that up to
    `finish_base_init'.
    * cplus-init.c (finish_stmt): Same change.

    * cplus-init.c (finish_base_init): Test "in charge" variable and
    conditionally do all virtual baseclass initialization.

    * cplus-class.c (build_method_call): New flag LOOKUP_HAS_IN_CHARGE
    which means that parameter list comes with the "in charge"
    parameter already set up.  If the call is to a constructor, and
    this flag is not set, then say we are "in charge" iff constructor
    called is for new object.
    * cplus-init.c (expand_aggr_init_1): Add "in charge" parameter
    when appropriate, and set FLAGS in those cases.

    * cplus-method.c (fndecl_as_string): Don't print "in charge"
    variable when formatting constructors for objects with virtual
    baseclasses.

    * cplus-tree.h (lang_decl): Add bit for constructors which build
    objects with virtual baseclasses.  These constructors take a new
    extra argument after the `this' pointer that says whether they are
    "in charge" of initializing virtual baseclass things or not.
    * cplus-decl2.c (grokclassfn): Set DECL_CONSTRUCTOR_WITH_VBASE_P
    bit when appropriate.  Also, add extra parameter in that case.
    * All GNU C++ files: Change name of AUTO_DELETE_IDENTIFIER to
    IN_CHARGE_IDENTIFIER, since that is the correct generalization of
    its function, and thus allows the same identifier to be used in
    constructors and destructors.

Thu Dec 21 12:58:05 1989  Michael Tiemann  (tiemann at hudson)

    * cplus-init.c (expand_aggr_init): If initializing from a GNU C
    CONSTRUCTOR, consider the elts in the constructor as parameters to
    an implicit GNU C++ constructor.

Wed Dec 20 10:45:46 1989  Michael Tiemann  (tiemann at hudson)

    * cplus-decl.c (duplicate_decls): Don't know why I turned off
    propagation of DECL_IN_AGGR_P bit, but it needs to be
    on--otherwise we cannot catch duplicate method declarations in
    class scope.  Was it turned off (erroneously) for efficiency
    reasons?

    * cplus-class.c (convert_harshness): Don't see two functions
    needing user-defined type conversions as ambiguous is one comes
    from immediate class, when the other comes from a base class.

    * cplus-decl.c (grokdeclarator): Don't permit storage class
    specifiers in parameter declarations.

    * cplus-typeck.c (mark_addressable): Say we're sorry if named
    return value much change from register to memory.  Also, since
    TREE_ADDRESSABLE is checked at top, no need to recheck in various
    other parts.
    * cplus-cvt.c (build_up_reference): Same change.

    * stmt.c (expand_function_start): If function value is in a
    register, set TREE_REGDECL of the DECL_RESULT.

    * cplus-class.c (convert_harshness): Conversion of enum to int
    costs an extra penalty.  Also, don't permit one kind of enum to
    convert to another.

    * cplus-search.c (dfs_pushdecls): Only set TREE_USED to zero for
    FIELD_DECLS.  If we zero it out for e.g. VAR_DECLs, they won't get
    written out at end of file.

Tue Dec 19 17:19:31 1989  Michael Tiemann  (tiemann at hudson)

    * cplus-decl.c (finish_decl): If we are at top level and
    allocation is temporary, switch to permanent allocation before
    calling `grok_reference_init'.  Also, initialization of references
    was losing when initializer was a constructor.
    @@ Problem that must be better solved: The compiler was confused
    about what NEW_EXPR meant--when it when looking for temp space for
    the reference, it was grabbing space from the file-level
    initialization function, not from static space.  What's needed is
    objects which really know how to get the kind of space they are
    looking for when they are really expanded.

    * cplus-type2.c (build_functional_cast): Check that type is
    defined before testing various constructor bits.

Thu Dec 14 15:14:12 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-tree.c (make_deep_copy,copy_to_permanent): New functions.
    * cplus-init.c (build_new): Dec 12 change was wrong.  Instead,
    call copy_to_permanent if we need to stash away the initializer.

Tue Dec 12 01:16:31 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-init.c (build_new): Check that INIT is not NULL_TREE
    before checking its permanence.

    * cplus-decl.c (decls_match): If TREE_TYPE (NEWDECL) is
    ERROR_MARK_NODE, don't call comptypes.

    * cplus-decl2.c (grokclassfn): Parameters for constructors with
    virtual baseclasses must be build on permanent_obstack.

    * cplus-parse.y (member_init): If using old-style member
    initialization for base class, remember to move allocation to the
    permaent_obstack before reading the initializer.

    * cplus-class.c (build_method_call): If global member function is
    good, record that fact in BEST.  That way our early-out for member
    functions won't accidently call an inferior member function.

    * cplus-decl.c (grokdeclarator): If TREE_CODE (decl) ==
    ERROR_MARK, then silently continue processing, rather than
    aborting compilation.

    * cplus-parse.y (except_stmts): Call `expand_start_catch' and
    `expand_end_catch' instead of `expand_exit_except' when expanding
    default catch clause.  Otherwise, we scream out to the next
    handler, not to the point after the handler.

    * cplus-class.c (build_overload_call): continue statement missing
    in TYPE_DECL case.

Sat Dec  9 23:27:56 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-decl.c (xref_tag): Mark REF in addition to all its
    basetypes so we can protect against the user declaring recursive
    types by accident.  Also fixed Braino in testing value of I after
    the BINFO loop.

Thu Dec  7 16:37:28 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-search.c (dfs_record_inheritance): Check that MI_SIZE is
    nonzero before entering loop which uses it as stride.

    * cplus-typeck.c (build_component_ref_2): Make subroutine of code
    which builds the final COMPONENT_REF structure because it must be
    recursive in the case we have a field from a base class of a
    virtual base class.

Wed Dec  6 08:05:59 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c (build_scoped_method_call): Dec 2 introduced a bug
    by attempting to optimize tree node allocation.  Fixed by always
    converting EXP.

    * cplus-decl.c (grokdeclarator): If TYPE becomes ERROR_MARK_NODE,
    and we are chasing down the declarator, must chase to TREE_OPERAND
    (DECLARATOR, 1) if TREE_CODE (DECLARATOR) is SCOPE_REF.

    * cplus-class.c (finish_struct): Change criterion for building
    init list from != CONST_DECL to == FIELD_DECL.  Also, don't count
    a class as needing constructing or needing constructor based on
    static members.

    * cplus-init.c (expand_vec_init): Call itself recursively with
    FROM_ARRAY nonzero if TREE_TYPE (init) is same as TREE_TYPE (exp).
    Also, if coming FROM_ARRAY, only call `expand_aggr_init' if there
    is a constructor to call.  Otherwise, call `expand_assignment'.

    * cplus-class.c (finish_struct): Can't have a default constructor
    if the class has reference types without default initial values.

    * cplus-tree.h (TYPE_RAISES_EXCEPTIONS): Use TYPE_NAME instead of
    (tree) TYPE_LANG_SPECIFIC.
    * cplus-decl.c (duplicate_decls): Now TYPE_LANG_SPECIFIC implies
    IS_AGGR_TYPE always.

    * cplus-init.c (build_default_constructor): Don't build
    initializer for default members.

    * cplus-class.c (finish_struct): If FUNCTION_DECL has
    IDENTIFIER_ERROR_LOCUS set, then don't keep the function in the
    class.  It is evil.

    * cplus-init.c (expand_member_init): Don't permit initialization
    of member from base class--unless baseclass is virtual and has no
    constructor.
    * cplus-init.c (member_init_ok_or_else): New function
    encapsulating this and other checks for validity of member
    initialization.

    * cplus-type2.c (build_functional_cast): Try going through type
    conversion function if no constructors apply.

    * cplus-typeck.c (c_expand_return): When returning a named return
    value, call `use_variable' on the result, in case it is in a
    register.

    * cplus-class.c (compute_conversion_costs): Don't warn about
    contravariance violations (or other problems) as a result of
    calling `comp_target_types' (via call to `instantiate_type').

    * cplus-init.c (expand_aggr_init): Check that INIT is nonzero
    before accessing its TREE_TYPE.

Tue Dec  5 00:13:33 1989  Michael Tiemann  (tiemann at arkesden)

    * integrate.c (copy_rtx_and_substitute): If we folded something
    completely into a constant, don't try to make it a legitimate
    memory reference out of it.

    * cplus-class.c (propagate_basetype_offsets): Forgot to set
    ASSOC_TYPE (ASSSOC) when building the new basetype.

    * cplus-init.c (expand_aggr_init): When initializing const array,
    turn off const bits during initialization.  Otherwise constructor
    can't be called (since it is calling from const object to
    non-const member function).

    * cplus-method.c (build_overload_name): Set PARMTYPE to
    TYPE_MAIN_VARIANT (PARMTYPE) after extracting interesting bits.

Mon Dec  4 04:56:08 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-decl.c (finish_decl): wrt Nov 14 change, only change
    DECL_NAME of TTYPE if DECL is not a FUNCTION_DECL.  It screws up
    consing up of default functions.
    * cplus-decl.c (grokdeclarator): When replacing anonymous aggr
    names with reasonable aggr names, change the names of any default
    constructors and/or destructors.

    * cplus-tree.h (type_flags): Added bits for
    TREE_GETS_CONST_{ASSIGN,INIT}_REF.
    * cplus-decl.c (grok_{ctor,op}_properties): Set bits here.
    * cplus-class.c (finish_base_struct): Read bits here.
    * cplus-class.c (finish_struct): If

    * cplus-init.c (expand_vec_init): Implement copy initialization
    from one vector to another (to make X(X&) work if members
    are vectors of X).  Added parameter FROM_ARRAY to signify this
    fact.
    * All callers changed.

    * cplus-decl.c (grokdeclarator): Test for validity of destructor
    declaration was too harsh.  It was not allowing one to declare
    that a destructor from a base class had public visibility in the
    current class.

    * cplus-method.c (hack_identifier): Vestigial double TREE_VALUE.
    Now that we use baselinks, everything is one level of list.

    * expr.c (expand_builtin): Fixed for BUILTIN_SAVEREGS case, again.
    This time, loop was failing because there was only one insn being
    protected.  Now, emit a note, so that loop terminates properly.

    * cplus-decl.c (build_default_constructor): Handle initialization
    of anonymous unions by bitwise copy.
    * cplus-init.c (finish_base_init): Handle wholesale initialization
    of anonymous unions, i.e., the whole union, rather than just any
    one member.

Sun Dec  3 13:32:29 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-decl.c (grok_ctor_properties): Add argument CTYPE to say
    what class type we are grokking for.

    * All GNU C++ files: Changed tests against IS_AGGR_TYPE when test
    against TYPE_LANG_SPECIFIC tests the property in which we are
    interested.

    * cplus-decl.c (grok_ctor_properties): Notice whether constructor
    can be used as default constructor, i.e., X ().
    * cplus-class.c (base_info): Add new fields `needs_default_ctor'
    and `cant_have_default_ctor'.  Set the former if any of the
    basetypes define a default constructor.  Set the latter if and of
    the basetypes define constructors, but not the default
    constructor.
    * cplus-class.c (finish_struct): If NEEDS_DEFAULT_CTOR and not
    CANT_HAVE_DEFAULT_CTOR, then cons up a default constructor for T.
    * cplus-lex.c (cons_up_default_function): Handle this new kind of
    default constructor.
    * cplus-decl.c (finish_function): Ditto.

    * cplus-typeck.c (build_modify_expr): Change assignment to this
    from error to warning if FLAG_THIS_IS_VARIABLE.

    * cplus-class.c (finish_struct): Build default X(X&) constructor
    if there are *any* constructors, not just if there are inherited
    X(X&) constructors.

    * integrate.c (function_cannot_inline_p): Raise threshold from 3
    to 4, since we copy more NOTEs now.

    * cplus-decl.c (finish_function): If DECL_CONSTRUCTOR_P (FNDECL)
    and DECL_COMPILER_GENERATED_P (FNDECL), do the default thing for
    this constructor (memberwise initialization).  Done by calling
    `build_default_constructor'.
    * cplus-decl.c (build_default_constructor): New function.

    * cplus-lex.c (cons_up_dtor_for_type): Change name to
    `cons_up_default_function'.  Takes new argument KIND saying what
    kind of default function to build.  Cons up destructor or X(X&)
    constructor depending on KIND.
    * cplus-init.c (expand_aggr_init_1): Test TYPE_HAS_INIT_REF, not
    TYPE_GETS_INIT_REF.
    * cplus-typeck.c (convert_for_initialization): Ditto.  If !HAS,
    but GETS, then abort for now.

    * cplus-class.c (finish_base_struct): Propagate
    TYPE_GETS_ASSIGN_REF.
    * cplus-class.c (finish_struct): If TYPE_GETS_ASSIGN_REF (T)
    but not TYPE_HAS_ASSIGN_REF (T), then default.
    * cplus-decl.c (grok_ctor_properties): Set TYPE_HAS_INIT_REF along
    with TYPE_GETS_INIT_REF.

    * cplus-init.c (build_delete): Don't check PROTECT when converting
    the object to be destroyed from derived type to base type.
    Leave it up to whether the destructor is visible or not
    to make that decision.

    * cplus-typeck.c (actualparameterlist): New parameter FLAGS.
    * cplus-typeck.c (convert_for_initialization): Ditto.
    * cplus-cvt.c (convert_to_reference): Change PROTECT to FLAGS.
    * cplus-cvt.c (build_up_reference): Ditto.
    * All callers changed.

    * cplus-init.c (build_delete): When deleting members, use PROTECT
    rather than 1 as value for calling `build_delete' recursively.

    * cplus-decl2.c (grokfield): If the initializer winds up being
    `error_mark_node', wrap it in a NOP so `decl_constant_value' will
    do the right thing.

    * cplus-decl.c (grokparms): If default parameter needs
    type instantiation, do it.

    * cplus-typeck.c (build_modify_expr): Cast first expression in a
    COMPOUND_EXPR to VOID_TYPE_NODE to suppress warning from
    warn_if_unused_value.

Sat Dec  2 16:57:52 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c (build_scoped_method_call): Extra TREE_TYPE around
    TREE_TYPE (decl) in two places.  Improved comments.  Make DECL be
    consistently of aggregate type.

    * cplus-tree.h (lang_type): `type_flags' substructure was not
    multiple of 4 bytes.

Fri Dec  1 05:08:57 1989  Michael Tiemann  (tiemann at arkesden)

    * integrate.c (try_fold_cc0): Argument to `emit_jump' was wrong:
    called with LABEL_REF rtx instead of underlying CODE_LABEL.

    * cplus-class.c (add_virtual_function): Handle case where virtual
    function is declared twice in the same class.

    * cplus-decl.c (finish_decl): Length argument to `bcopy' was off
    by one for anonymous aggregate names was off by one.

Thu Nov 30 16:29:42 1989  Michael Tiemann  (tiemann at arkesden)

    * expr.c (expand_builtin): In BUILTIN_SAVEREGS case, advance
    SAVING_INSNS after noting stores.

Wed Nov 29 05:35:59 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-except.c (expand_cplus_reraise): If an exception was not
    on the legal list of exceptions to reraise, don't bother
    protecting the raised object by assigning zero to its pointer.

    * cplus-class.c (build_method_call): When calling a non-const
    member function from a const member function, tell which non-const
    member function is being called.  Also, return ERROR_MARK_NODE if
    we are not looking up to complain.

    * cplus-type2.c (build_functional_cast): Due to typedefs, we must
    pull NAME from TYPE.

    * cplus-typeck.c (build_compound_expr): If TREE_VALUE of list is a
    VAR_DECL, use result of calling `decl_constant_value'.

    * stmt.c (expand_end_except): PREV was uninitialized.

    * stmt.c (expand_exit_except): New function, like
    `expand_exit_loop'.  Used to explicitly exit an except contour.
    * cplus-parse.y,cplus-except.c: Replace calls to
    `expand_exit_something' with calls to `expand_exit_except'.
    * cplus-decl.c (start_function): If FLAG_HANDLE_EXCEPTIONS, build
    an exception contour around the outermost binding level.
    * cplus-decl.c (finish_function): If FLAG_HANDLE_EXCEPTIONS, clean
    up that countour after the last binding contour goes away.
    * stmt.c (in_{try,except}_block): Added LEVEL parameter.
    * stmt.c (in_exception_handler): Added LEVEL parameter.
    * cplus-except.c: All callers to `in_try_block' as about level 1
    instead of immediate level, because outermost try block doesn't
    really count.

    * cplus-except.c (cplus_expand_end_except): Call abort if catching
    unhandled exception at outermost level.

Tue Nov 28 06:51:48 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-except.c (expand_cplus_raise): Interface changed to take
    third parameter which is the already-constructed object to be
    raised, allowing `expand_cplus_reraise' to call this function.

    * cplus-parse.y (try RERAISE raise_identifiers): Actually
    implement this now.
    * cplus-except.c (expand_cplus_reraise): Ditto.

    * cplus-decl.c (init_decl_processing): Initialize LANG_NAME_C and
    LANG_NAME_CPLUSPLUS.  Initialize CURRENT_LANG_NAME to LANG_NAME_C.
    * cplus-class.c (init_class_processing): Initialization of
    LANG_NAME_{C,CPLUSPLUS} was too late here.

    * cplus-decl.c (duplicate_decls): If NEWDECL is a FUNCTION_DECL,
    and it was the last object allocated on the permanent_obstack, cut
    the permanent_obstack back to NEWDECL, since we have OLDDECL.

    @ The following three changes are conditional on actually defining
    LANG_DECL_PERMANENT in cplus-tree.h.  It is currently not defined
    becuase a good solution for saving lang_decls might require more
    space than the space that could be reclaimed.

    @ cplus-tree.h (lang_decl): New bit LANG_DECL_PERMANENT says if
    the lang_decl was allocated on the permanent_obstack.
    @ cplus-lex.c (build_lang_decl):  Set it if appropriate.  New
    variable FREE_LANG_DECL_CHAIN holds previously freed LANG_DECLs.
    @ cplus-decl.c (duplicate_decls):  Add the lang_decl of the old
    decl to FREE_LANG_DECL_CHAIN if it was allocated on the
    permanent_obstack.

    * cplus-decl.c (duplicate_decls): Preserve DECL_LANGUAGE when
    NEWDECL is a definition.
    * cplus-decl.c (start_function): Don't set DECL_LANGUAGE here, now
    that it is properly handled in `duplicate_decls'.  Also, set
    DECL_OVERLOADED (DECL1) from DECL_OVERLOADED (OLDDECL).

Mon Nov 27 06:30:53 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-method.c (dump_init): Argument to `dump_type' was missing
    in SAVE_EXPR case.

    * cplus-class.c (compute_conversion_costs): While it is probably
    an error to permit a call from a const member function to a
    non-const member function, cfront seems to do it, grudginly.
    Change this function to make this conversion cost the heaviest of
    built-in conversion costs, to give behavior that matches cfront.
    This can easily be changed back to error-giving behavior.
    * cplus-class (build_method_call): Give warning if calling to
    non-const member function from const member function.

    * cplus-method.c,cplus-class.c: Change name of
    `do_actual_overload' to `build_overload_call', and move the
    function from cplus-method.c to cplus-class.c.  Also, rewrite
    slightly to call `build_decl_overload', removing duplicated code.
    * cplus-typeck.c (build_x_function_call): Change the name of
    called function.

    * cplus-tree.c (hash_tree_cons): Typo--set TREE_VIA_PUBLIC twice,
    instead of TREE_VIA_PUBLIC and TREE_VIA_VIRTUAL.

    * cplus-decl.c (finish_decl): It is INIT, and not
    DECL_INITIAL (DECL) which holds the real value of DECL's
    initializer.  We need INIT's value for `complete_array_type' to do
    its job.

    * expr.c (save_noncopied_parts): Deal with case of having
    `assign_stack_local' return an invalid memory reference.

    * cplus-typeck.c (build_component_ref): 11/26 fix was almost
    right, but called `value_member' in first case where should have
    called `assoc_value'.

    * cplus-init.c (expand_vec_delete): Lines were reversed in
    multi-dimensional array code.

    * version.c: Test release version 1.36.2-

    * integrate.c (expand_inline_function): Bug in use of
    CONST_EQUIV_MAP did not work correctly in the presence of loops
    for variables initialized in first basic block but modified within
    a loop body.

Sun Nov 26 17:11:08 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-init.c (build_new): Handle case when TRUE_TYPE gets
    ERROR_MARK_NODE, such as when the size expression for an ARRAY_REF
    is ERROR_MARK_NODE.

    * cplus-type2.c (digest_init): Catch case where ELEMENT is
    ERROR_MARK_NODE, which avoids calling `comptypes' with
    ERROR_MARK_NODE as our type (recall that TREE_TYPE (ERROR_MARK_NODE)
    is ERROR_MARK_NODE, not NULL_TREE).

    * cplus-typeck.c (build_component_ref): Forgot to pull offset from
    association of type once we found the field!  This causes fields
    in two separate baseclasses to overlap when referenced from a
    class deriving from the baseclasses.

    * cplus-parse.y (primary, primary_no_id): Recognize
    `SCOPE operator_name'.

    * cplus-decl.c (grok_reference_init): Code to permit references to
    arrays was somehow missing.  Also, in the case where DECL is
    TREE_STATIC and the initializer is TREE_LITERAL, no need to call
    `expand_static_init'.

    * cplus-tree.h [DECL_OVERLOADED]: User `overloaded_attr' in
    lang_decl to distinguish overloaded functions from nonoverloaded
    ones.
    * cplus-tree.h [DECL_EXTERNAL]: Use TREE_LANG_FLAG_1 instead of
    TREE_LANG_FLAG_3.  The latter was used for TREE_PRIVATE.

    * cplus-init.c (expand_vec_delete): Handle multi-dimensional
    arrays.

    * cplus-decl.c (duplicate_decls): Copying of DECL_IN_AGGR_P bit
    was backwards.
    * cplus-decl.c (start_decl): And need to turn off DECL_IN_AGGR_P
    when seeing this decl in non-aggr context.  Also, clear
    TREE_EXTERNAL if DECL_EXTERNAL is not set.

    * cplus-decl.c (grok_reference_init): Code split from
    `finish_decl' for modularity.

Sat Nov 25 06:29:08 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl.c (grokdeclarator): Was incorrectly rejecting
    class-local typedefs which had things like RID_LONG (thought they
    were storage class specifiers).

    * cplus-method.c (report_type_mismatch): Corrected error
    introduced by making INLINE_BUFFER non-static.

    * cplus-tree.c (build_exception_variant): Correctly handle case
    when RAISES is NULL_TREE.

    * cplus-except.c (lookup_exception_object): Switch to
    permanent_obstack when implicitly declaring an exception object.

    * cplus-class.c (instantiate_type): Handle TREE_LIST of
    FUNCTION_DECL in addition to TREE_LIST of TREE_LIST of
    FUNCTION_DECL.  The former is what a BASELINK in disguise.

    * cplus-decl.c (grokdeclarator): Don't crash if TYPE ==
    ERROR_MARK_NODE when DECL_CONTEXT == FIELD.  Happens when array
    size is undefined, for example.

Fri Nov 24 16:04:44 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-search.c (get_baselinks): When we get to end of search
    (i.e., TYPE has only one basetype), propagate BASELINKs.

    * cplus-decl.c (shadow_tag): Missing call to
    `end_exception_decls'.

Tue Nov 21 23:40:57 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-method.c: Change from static allocation of INLINE_BUFFER
    to dynamic, saving 8k static data size.
    * cplus-method.c (fndecl_as_string): Initialize INLINE_BUFFER
    always from BUF.
    * cplus-class.c, cplus-tree.c: Callers of `fndecl_as_string'
    changed.

Mon Nov 20 20:56:49 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c (build_method_call): Don't check visibility on
    calls to wrappers.

    * cplus-tree.h: Delete bitfields HAS_WRAPPER and NEEDS_WRAPPER.
    Add field for TYPE_WRAP_TYPE.
    * cplus-decl.c, cplus-class.c: Set fields accordingly
    * cplus-class.c (build_method_call): Call `get_wrapper' if we need
    to be wrapping a function call.
    * cplus-search.c (get_wrapper): Implement this function.

Sat Nov 18 05:16:22 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-lex.c (check_newline): Recognize (but apologize about)
    #pragma newworld.

    * cplus-method.c (build_decl_overload): Compact encoding for
    member functions ifndef LONGERNAMES.
    * cplus-dem.c (cplus_demangle,do_args): Deal with different
    encoding ifndef LONGERNAMES.

    * cplus-tree.c (list_has_lookup_or_cons): New function optimizes
    most common case in parsing.
    * cplus-parse.y: Call in in place of `hash_tree_chain (_, NULL_TREE)'.

    * cplus-parse.y, cplus-lex.c: Gather statistics on tokens and
    reductions.

    * cplus-class.c (instantiate_type): Forgot to check COMPLAIN
    before complaining.

    * cplus-init.c (build_new,build_vec_delete): Call
    do_pending_stack_adjust before building and after finalizing
    RTL_EXPR.  Also removed bogus construct

           emit_insn (gen_sequence ());

    which was causing circular rtl to be output.  (Thanks to rms for
    identifying the problem!).
    * cplus-type2.c (make_merged_ref): Same change.
    * cplus-parse.y (except_stmts): Same change.

    * cplus-init.c (get_member_function): Wrap a SAVE_EXPR around the
    address of MEMBER.

Fri Nov 17 20:11:19 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-type2.c (store_init_value)

    * cplus-dem.c (do_type): Initialize NON_EMPTY.

Tue Nov 14 00:19:31 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-init.c (build_vec_delete): Call `emit_note' in case no
    code is emitted by `expand_vec_delete'.

    * cplus-parse.y (operator_name): If the operator name is
    erroneous, build something signifying that fact, rather than just
    returning NULL_TREE.

    * cplus-typeck.c (target_type): New function.  Returns the target
    type of TYPE.
    * cplus-decl.c (finish_decl): Call `target_type' to figure out the
    built-in type that DECL is based on.  If we find it to be
    ANON_AGGRNAME_P, then we must change it, since nothing else will,
    and the compiler will go into loops if expand_inline_function trys
    to push it back into the environment.

    * cplus-parse.y (primary): Need to do `lookup_name' on operator
    names that come through here.

    * stmt.c (expand_end_try): Jump to after label to avoid falling
    through into default handler.

    * cplus-decl.c (define_label): Don't complain about jumps past
    initialziation of compiler-generated temporaries.  They can't be
    accessed, and by the time we get to the label, they should be
    cleaned up.

Mon Nov 13 02:34:58 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-init.c (get_member_function): If EXP_ADDR was something
    hairy (like a CALL_EXPR), make EXP indirect from it.  This saves
    writing out twice the code (once for each branch of the
    conditional).

    * cplus-dem.c (cplus_demangle): Recognize virtual function tables.
    * Also, handle operator* and operator->().

    * cplus-class.c (finish_struct): Don't warn about all class
    members being private if there are public baseclasses.

    * cplus-decl.c (grokdeclarator): Catch case where friend function
    is declared with method qualifiers.

    * cplus-typeck.c (commontype): Get the right value for BASETYPE in
    METHOD_TYPE case.

    * cplus-method.c (build_opfncall): TYPE1 was being initialized too
    late.

    * cplus-dem.c[USG]: Use this instead of #ifndef sequent.

Sun Nov 12 01:35:08 1989  Michael Tiemann  (tiemann at arkesden)

    * integrate.c (note_integrated): New function.  If insn generated
    used constants, check that it is legit.  If not, delete it and
    return zero to caller, indicating that the caller should try
    again.  If successful, set RTX_INTEGRATED_P.

    * cplus-tree.c (layout_vbasetypes): Use `int' return type to
    advantage.

    * cplus-init.c (build_delete): Don't abort if TYPE ==
    ERROR_MARK_NODE.  It can happen.

    * integrate.c: Use "iteration numbering" to propagate constants
    through inline function expansion.

    * stmt.c: Added exception stmts to nesting stack.
    * cplus-except.c: Move appropriate stuff out of here.

Sat Nov 11 10:10:59 1989  Michael Tiemann  (tiemann at arkesden)

    * integrate.c: Make `expand_inline_function' smart enough to use
    constant when safe, and not when not.

    * integrate.c: Merged changes from rms as of today.
    * varasm.c: Merged changes from rms as of today.

    * cplus-except.c: Use variable TRY_DEPTH to determine whether we
    are inside a TRY block or not.
    * cplus-except.c (cplus_expand_{start,end}_try):
    Increment/decrement that variable.
    * cplus-except.c (expand_cplus_raise_stmt): If TRY_DEPTH is
    nonzero, then simply exiting the try block does all the right
    things.  Otherwise, we must use `longjmp'.

    * cplus-init.c (build_new): Don't use the RTL_EXPR hack for static
    initializations.

    * ld.c (write_output): Unconditionally remove the old file in case
    another owns it but user has write permission.

    * cplus-decl2.c (finish_file): Set DECL_PRINT_NAME of file
    clean/initialization functions to things we might want to print.

Fri Nov 10 19:08:51 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-tree.h: Get rid of EXCEPTION_LABEL_DECL, no longer needed.
    Add EXCEPTION_THROW_DECL.  This VAR_DECL is used to determine
    whether to throw from a binding contour using the exception
    handling machinery.
    * cplus-decl.c, cplus-except.c: Changes to adapt to new model.

    * tree.c (build_op_identifier): #if 0 in this file.
    * cplus-lex.c (build_op_identifier): define this function here.
    Change interface to take `tree_code' arguments instead of `tree'
    arguments.  Use memoizing table to preserve previously allocated
    nodes.
    * cplus-parse.y, cplus-method.c: Callers changed.
    * cplus-lex.c (build_operator_fnname): Can't get by on
    side-effecting an OP_IDENTIFIER's TREE_CODE anymore.  Change
    interface to pass OP_IDENTIFIER node in as a tree*, and set that.
    * cplus-decl2.c (grokopexpr): Must also take DECLARATOR in as
    pointer.

    * cplus-init.c (build_new): After calling `start_sequence', prime
    the insn pump by calling `emit_note' to emit a NOTE_INSN_DELETED.

Wed Nov  8 15:54:32 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-type2.c (build_functional_cast): Move from cplus-class.c
    to this file.

    * cplus-class.c (build_functional_cast): Don't assume that
    TYPE_NAME (TYPE) is a TYPE_DECL; it might be an IDENTIFIER_NODE.

    * gcc.c (main): Print out the name `g++' instead of `gcc' until
    the merge is complete.

Tue Nov  7 14:56:50 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-init.c (build_new): Initialize RVAL if SOS.

Mon Nov  6 00:51:43 1989  Michael Tiemann  (tiemann at arkesden)

    * crt1.c: Changes from Eirik Fuller (Cornell Theory Center) to fix
    incremental linking.
    * gnulib3.c (__do_global_cleanup): Also from Eirik: fixed braino
    that was not reinitializing __DLI.

    * cplus-method.c (build_overload_name): Mangle member functions
    with qualifiers differently than member functions without
    qualifiers.  Also, add 'F' before argument list for METHOD_TYPE,
    since cfront 2.0 seems to do so.
    * cplus-method.c (dump_type_suffix): Make formatting of these
    kinds of METHOD_TYPEs right.
    * cplus-dem.c (do_type): Grok these changes.

    * cplus-except.c (exception_object_name): Don't crash in case
    of ``raise all'', which comes encoded as VOID_TYPE_NODE.
    @@ Handle it correctly in next release.

    * cplus-decl2.c (grok_method_quals): New function.  Incorporate
    `const' and `volatile' qualifiers into FUNCTION_DECLs and
    TYPE_DECLs.  Uses code broken out of `grokclassfn'.
    * cplus-decl2.c (grokclassfn): Caller changed.
    * cplus-decl.c (grokdeclarator): Call `grok_method_quals' when
    QUALS is non-zero in declarator grokking loop.

Sat Nov  4 20:21:54 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-init.c (build_new): If TYPE_NEEDS_CONSTRUCTING (TYPE),
    then always wrap RVAL in an RTL_EXPR, since we don't know that we
    aren't one of the arms of a ?: operation.  RVAL can now be a
    SAVE_EXPR (normally) or a VAR_DECL (in the case of array
    initialization).

    * cplus-init.c (build_new): Fix braino that was causing array
    types to be collapsed into their element types, causing
    `build_new' to return a point to the element type, rather then a
    pointer to the array type.

    * cplus-decl2.c (grokfield): Check DECL_NAME (VALUE) before
    dereferencing it.

    * cplus-init.c (expand_vec_init): Do not fail to initialize
    element of an array which receive default initialization.

    * cplus-type2.c (digest_init): If TYPE needs constructing,
    don't convert INIT to TYPE.  The only time when this happens
    is when called upon to initialize an ARRAY_TYPE, and
    `expand_vec_init' will handle that case.

    * cplus-class.c (build_method_call): Error reporting for bad
    argument list was screwed for static member functions in static
    call context.

    * config.g++: Add MIPS-based configurations.

    * toplev.c: Make up for systems which do not have unistd.h (like
    many BSD systems).
    * Makefile: Add HAVE_UNISTD_H flag.

    * cplus-dem.c: Sequentize the code.

    * cplus-init.c (expand_cplus_expr_stmt): Warn if statement is just
    a reference to, and not a call of, some function.

Thu Nov  2 10:03:50 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-method.c (build_overload_name): Don't crash if we built a
    TREE_LIST which contains VOID_TYPE_NODE and which is not
    VOID_LIST_NODE.  This happens if one of the parameters is of type
    VOID_TYPE.

    * stmt.c (expand_return): Even when RETVAL has type VOID_TYPE, we
    must expand it (it may be a call to another void function).

    * integrate.c (copy_rtx_and_substitute): Moved one to many insns
    to BEFORE_INLINE_FP_RTX.

    * cplus-typeck.c (convert_for_initialization,actualparameterlist):
    Don't defaultly convert ARRAY_TYPE when converting to
    REFERENCE_TYPE.

Wed Nov  1 04:43:46 1989  Michael Tiemann  (tiemann at teacake)

    * stmt.c (init_function_start): Initialize MAX_PARM_REG to
    FIRST_PSEUDO_REGISTER.

    * cplus-init.c (expand_vec_init): This function can be called to
    initialize a non-aggregate vector.

Tue Oct 31 13:38:42 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-type2.c (process_init_constructor): Don't even try
    initializing a structure from EMPTY_INIT_NODE.

    * cplus-init.c (build_new): Handle case where SAVE_EXPR_RTL of
    new'd value is 0 by putting it CONST0_RTX.

    * cplus-typeck.c (build_component_ref): If the COMPONENT_REF is
    really a reference to a member function, do the right thing if the
    member function is virtual.

Mon Oct 30 00:39:18 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c (build_method_call): Removed code that seemed to
    build (superflouously) an INDIRECT_REF for INSTANCE just before
    heading to found/found_and_ok (where INSTANCE was just
    reinitialized).  Also, fixed bug so that if INSTANCE was of fixed
    type, that fact remained known even if INSTANCE_PTR became more
    distanct due to going through a NOP_EXPR.

    * cplus-init.c (get_member_function): Add parameter EXP_ADDR_PTR
    which is a pointer to the tree representing the address of EXP.
    Also, add hairy code which does the right thing wrt. modifying
    `this' pointer when it is argument to call.
    @@ This modification causes GNU C++ to generate stupid
    conditional-branch code when optimizing.  Hopefully future
    versions of the optimizer will understand and optimize it.
    * cplus-typeck.c (build_x_function_call): Caller changed.

    * cplus-tree.h (lang_type): Added new field GOT_SEMICOLON to
    TYPE_FLAGS field, to record whether a type has been `finished' or
    not.  Attempt to catch bugs like `struct s { .. } main () { .. }'.
    * cplus-parse.y (various rules): Add call to `note_got_semicolon'.
    * cplus-decl.c (start_function): Check that we have a `finished'
    type.
    * cplus-lex.c (note_got_semicolon): Set the bit here.
    * cplus-class.c (finish_struct): Whenever we start afresh with a
    class type, zero the bit here.

    * cplus-type2.c: Rename file cplus-typeck2.c to fit brain-damaging
    SVID 14 char name limit.

    * cplus-typeck.c (build_modify_expr): Handle case where assignment
    comes from friend, rather than member function.

    * cplus-tree.c (lang_printable_name): Handle case where DECL's
    language specific field is nonexistent.
    * cplus-method.c (fndecl_as_string): Here too.

    * cplus-decl.c (finish_decl): Initialization of a reference from
    `*this' was falling down because nodes for `$this' were getting
    shared too much.

    * cplus-tree.h (TREE_HAS_CONSTRUCTOR): Reincarnate use of this
    flag--for SAVE_EXPR it means that underneath lies a call to
    `new' for a given type.
    * cplus-init.c (build_new): Set the flag.
    * cplus-method.c (dump_init): Test it.

    * cplus-tree.h (PARM_DECL_EXPR): Use this flag to distinguish
    parsing initializers for PARM_DECLs from initializers for global
    variables.
    * cplus-decl2.c (finish_file): Don't emit anything from
    STATIC_AGGREGATES that was really just for default parameters.
    * cplus-decl.c (grokparms): Set PARM_DECL_EXPR on SAVE_EXPRs.
    * cplus-method.c (dump_init): Same.

Sun Oct 29 23:23:48 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-method.c (build_opfncall): Don't check visibility here for
    operators `new' and `delete' unless within a constructor or
    destructor.
    * cplus-decl.c (finish_function): Add checks for visibility of
    those operators here instead.

    * cplus-decl2.c (groktypefield): Handle case where field name
    conflicts with a typedef.

Fri Oct 27 01:02:20 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-search.c (get_virtuals_named_this): Return a baselink
    instead of a FUNCTION_DECL.  Also, walk through FIELDS as
    baselinks.  I.e., use `next_baselink' instead of TREE_CHAIN.

    * cplus-search.c (get_first_matching_virtual): Caller changed.

Thu Oct 26 16:09:07 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-search.c (get_first_matching_virtual): Only complain about
    a particular property of a virtual function once.

    * cplus-class.c (finish_struct): If ASSOC winds up being zero,
    don't frob the vtable.

    * cplus-decl.c (shadow_tag): Handle case where exception does not
    have any fields.
    * cplus-parse.y (component_decl): Handle case where exception does
    not have any fields.

    * cplus-parse.y (structsp): Call `finish_exception' with only two
    parameters.

    * cplus-parse.y (stmt): Forgot ';' after `RAISE' stmt.

    * cplus-class.c: Gather statistics on number of elments in virtual
    function tables, number of entries we build for them, and number
    of virtual function table entries we search using linear lookup.

    * cplus-parse.y (aggr,opt.component_decl_list): Call
    `build_tree_list' instead of `decl_tree_list', because of nested
    structures.  Would be better to make TEMP_DECL_OBSTACK pushable
    like the momentary obstack, but we don't for now.

Tue Oct 24 06:26:13 1989  Michael Tiemann  (tiemann at arkesden)

    * integrate.c (copy_rtx_and_substitute): Don't change something to
    a memory address unless it really is `memory_address_p'.

    * cplus-decl.c (finish_decl): Handle array initialization if type
    of array needs constructor.  Also, implement initialization
    without INIT0 crutch.
    * cplus-init.c (expand_vec_init): Handle array initialization from
    {...} where type of array needs constructor.

    * cplus-typeck.c (build_binary_op_nodefault): Make compiler give
    error, not warning, if comparing pointers with integers.

    * cplus-typeck.c (build_component_ref): Call `lookup_fnfields' to
    get a list of methods.

Mon Oct 23 17:29:03 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-tree.h (lang_decl): Add bit `COMPILER_GENERATED' to
    indicate whether this FUNCTION_DECL was generated automatically by
    the compiler.
    * cplus-lex.c (cons_up_dtor_for_type): Set this bit.
    * cplus-decl.c (redeclaration_error_message): Give better error
    message if user redeclares something that was implicitly created
    by the compiler.

    * cplus-decl.c (finish_decl): Test DECL_LANG_SPECIFIC before
    testing DECL_IN_AGGR_P in case of init-free reference decl.

Sat Oct 21 10:29:09 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c (build_method_call): Forgot to increment b_or_d as
    we go through class hierarchy.  Probably fell out as a result of
    `next_baselink' change on Friday, Oct 13.

    * cplus-cvt.c (build_up_reference): When calling
    `convert_to_nonzero_pointer', use TYPE_MAIN_VARIANT so that
    TYPE_POINTER_TO is defined.

    * cplus-search.c ({push,pop}_memoized_context): Plug memory leak
    by freeing pushing and popping the TYPE_OBSTACK irrespective of
    whether we are memoizing lookups or not.

    * cplus-decl2.c (grokclassfn): Don't make `this' TREE_READONLY
    inside of destructors.

    * cplus-search.c (get_abstract_virtuals): New function.  Returns
    the list of virtual functions that are considered abstract for a
    given type (i.e., those which are ` = 0' in declaration).
    * cplus-class.c (finish_base_struct): Call it.

    * All GNU C++ files: change names containing `UNINHERIT*' to names
    containing `ABSTRACT'.  Eliminate use of
    CLASSTYPE_HAS_ABSTRACT_VIRTUALS in favor of testing
    CLASSTYPE_ABSTRACT_VIRTUALS directly.

    * cplus-decl.c (start_function): Handle case where user names and
    internal names conflict.

    * cplus-typeck.c (build_conditional_expr): Put type instantiation
    back in.

    * cplus-decl.c (start_function): Use DECL_STATIC_CONTEXT instead
    of DECL_CONTEXT for pushing into context of static function.

    * cplus-decl.c (auto_function): Like `builtin_function', but
    builds an overloadable function.
    * cplus-decl.c (init_decl_processing): Call it for __builtin_new,
    __builtin_delete and similar functions.

Fri Oct 20 02:22:06 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-decl.c (finish_decl): Set TREE_USED bit of DECL if DECL is
    a const VAR_DECL at TOPLEVEL.

    * cplus-class.c (modify_vtable_entry): Still more fixes to code
    which computes derived vtable.

Thu Oct 19 11:14:55 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c (finish_struct): Move code that sets
    TYPE_USES_MULTIPLE_INHERITANCE from here...
    * cplus-decl.c (xref_tag): ...to here.

    * cplus-decl.c (finish_decl): Oct 12 change to implement
    initialization of class members so that their initializers could
    use private members did not test DECL sufficiently.  In addition
    to checking DECL_CONTEXT, must also check that TREE_CODE (DECL) ==
    VAR_DECL.  Otherwise redeclaration of member functions cause
    crashes.

Tue Oct 17 03:34:05 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-method.c (hack_identifier): Use `error', not
    `error_with_decl' to report that a non-static member is being
    referenced in a static member function.

    * cplus-decl.c (duplicate_decls): TREE_INLINE was not being set
    for OLDDECL, which is really where it matters.

    * cplus-typeck2.c (merge_component_comparisons): Track TEM1 in
    addition to TEM0 in loop which computes BITPOS0.

    * cplus-decl2.c (grokfield): Set CLASSTYPE_LOCAL_TYPEDECLs from
    CURRENT_CLASS_TYPE rather than DECL_CONTEXT (VALUE), since the
    latter is not set up for TYPE_DECLs.

    * cplus-decl.c (xref_tag): Set CLASSTYPE_DECLARED_CLASS each time
    we see an xref to this tag until we see the actual type defined
    for this tag.

Mon Oct 16 01:48:27 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-tree.h (DECL_VIRTUAL_P): If set in an IDENTIFIER_NODE, it
    means that somebody has defined a virtual function with this name.
    * cplus-decl.c (grokfndecl): Set it.
    * cplus-search.c (get_first_matching_virtual): Use it.

    * cplus-decl.c (cplus-tree.h): Define DECL_EXTERNAL as synonym for
    TREE_LANG_FLAG_3, which means for a VAR_DECL to mean that `extern'
    was specified in for that VAR_DECL.
    * cplus-decl.c (grokvardecl): Set DECL_EXTERNAL.
    * cplus-decl.c (duplicate_decls): Set TREE_PUBLIC of `const'
    variables based on TREE_STATIC and DECL_EXTERNAL.

Sun Oct 15 00:44:01 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-decl.c (start_function): Set CURRENT_EXTERN_INLINE from
    TREE_PUBLIC of DECL1 if DECL1 came pre-parsed.

    * cplus-decl2.c (finish_file): Don't write out inline functions
    which had their address taken if they were declared
    `extern inline'.

    * cplus-decl.c (grokdeclarator): Don't set TREE_PUBLIC based on
    INLINEP here.  Also, don't treat RID_INLINE as being a storage
    class for `multiple storage classes' error message.
    * cplus-decl2.c (grokfield): Do it instead here.
    * cplus-init.c (do_friend): And here.
    * cplus-decl.c (duplicate_decls): And change this to more match
    how GCC does things.

    * cplus-lex.c [USG_STDIO]: Use this instead of USG, for turncoats
    who have enough of System V that their stdio is broken, and too
    much Berkeley for USG to be the right thing.

    * cplus-decl.c (grokdeclarator): Grok declarations of the form
    `X x(args)[size]' to mean ARGS is an initializer to the array
    constructor for X[SIZE].
    * cplus-decl2.c (finish_file): Handle new case.

    * cplus-method.c (build_opfncall): Don't abort if user makes a bad
    call to operator new.  It's not the compiler's fault.

    * cplus-init.c (finish_base_init): Unmark virtual baseclasses
    which have explicit initializers.

    * cplus-init.c (expand_aggr_init_1): Change PROTECT parameter to
    FLAGS parameter.  All callers changed.

    * cplus-decl.c (finish_function): In destructor code, it is
    CLASSTYPE_VSIZE, not TYPE_VIRTUAL_P, which is the operative
    value to test when building base destructor code.  See Sept 1
    change for more info.

    * cplus-parse.y (unary_expr): Arguments to build_vbase_delete were
    wrong: was passing POINTER_TYPE and address when should have been
    passing object type and object.

Sat Oct 14 06:45:34 1989  Michael Tiemann  (tiemann at arkesden)

    * stmt.c (expand_anon_union_decl): For anonymous unions in memory,
    don't call `change_address'.  Just cast the memory reference
    ourselves.

    * cplus-typeck2.c (store_init_value): Don't test PEDNATIC to see
    whether to permit initialization of static variable from
    non-constant, since C++ 2.0 defines it to work.

    * cplus-init.c (expand_aggr_init_1): PARM_SLOTS was allocating
    sizeof (char) instead of sizeof (struct rtx_def*).

    * cplus-decl.c (grokfndecl): Call to `get_first_matching_virtual'
    must be followed by code which, under certain cases, goes all the
    way down the inheritance hierarchy to match the virtual function.
    Otherwise, the wrong virtual function tables come in to play when
    the time comes to reconcile them (in modify_vtable_entry).  Note
    that the call to `get_first_matching_virtual' does the right thing
    within `finish_struct'.  In that case, since we pull BASE_FNDECL
    from a virtual base class's virtual function table, there is no
    issue where it should be thought of as coming from.

    * cplus-search.c (rank_mi_virtuals): Spurious TREE_TYPE made it
    look like we were trying to compare PARM_DECLs instead of _TYPE
    nodes in our list at some time.

    * cplus-search.c (get_first_matching_virtual): Friday the 13th
    change was wrong.  Instead, make `get_first_matching_virtual'
    handle the instance variable itself, and call `compparms' as
    before.

    * cplus-lex.c (reinit_parse_for_method): Null character was being
    inserted if USG hack to round up buffer length was being used.

    * cplus-class.c (compute_conversion_costs): When trying a type
    conversion, use the actual type that the function wants.  No
    reference-bashing here!

    * cplus-search.c: Add a new obstack BRIDGE_OBSTACK which contains
    the class declarations across scopes.  This is an alternative to
    building their lists on the permanant_obstack.
    * cplus-search.c (push_search_level): Record the obstack for which
    this level was pushed.
    * cplus-search.c (pop_search_level): Remove OBSTACK parameter.
    Get that value from the search level that is being popped.

    * cplus-tree.h (lang_type): Add a slot for the instance variable.
    * cplus-decl.c (start_function): Use it.

    * tree.c (build_nt0): New function.  Use this to build declarators
    instead of `build_nt'.  Uses new obstack `temp_decl_obstack'.

    * cplus-cvt.c (build_type_conversion): Distinguish void* from
    const void* if we are trying to convert from some arbitrary
    pointer to a void* variant.

    * cplus-class.c (finish_struct_bits): New function.  Code broken
    out of `finish_struct'.  Extend to handle both conversions to
    const pointers and conversions to non-const pointers.

    * cplus-tree.h (lang_type):  Extend to handle both conversions to
    const pointers and conversions to non-const pointers.

    * cplus-decl.c (start_function): FNTYPE was not re-set after
    calling `pushdecl'.  Consequently, static member functions with
    default arguments were breaking.

    * cplus-class.c (pushclass): When pushing tags into the class
    binding level, push the TYPE_DECL, not the _TYPE into the
    IDENTIFIER_CLASS_VALUE slot.

    * cplus-method.c (fndecl_as_string): Don't skip first parameter if
    FNDECL is a static member function.

    * gplus.gperf [CATCH]: Add it.

    * cplus-init.c (build_member_ref): Nodes returned from
    lookup_fnfields are not saved on the permanent obstack, regardless
    of CURRENT_OBSTACK.  This is usually ok, since they are usually
    only used as a structure through which search machinery will
    traverse looking for values that do live on the permanent obstack.
    One exception is when `build_member_ref' builds an expression
    which requires type instantiation at top-level.

    * cplus-decl.c (finish_decl): Give better error messages for
    initialization of references, and remove invalid messages as well.
    Initialization of type-qualified references is different than
    initialization of type-qualified pointers in the following way:
    you can initialization a `X&' from a `const X&', but you cannot
    initialize a `X*' from a `const X*'.  This is because the compiler
    can convert the `const X&' to a `const X', create a new temporary,
    and take a reference from that.

    * cplus-init.c (is_friend): In testing for friendly classes, allow
    for static member functions to be considered friends.

Fri Oct 13 00:03:18 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-decl.c (grokdeclarator): If DECL_CONTEXT is FIELD for
    building a TYPE_DECL, allocate using `build_lang_field_decl'
    instead of `build_decl'.

    * cplus-decl.c (xref_tag): Undo Sept 10 change.  It causes
    problems for InterViews.  Better to work around in ET++.

    * cplus-decl.c (lookup_name): When looking up NAME, if
    CURRENT_CLASS_TYPE is being defined, check its baseclasses for a
    definition of a TYPE_DECL.

    * cplus-decl.c (grok_enum_decls): Return DECL, not NULL_TREE if
    TYPE has already been recorded.

    * cplus-search.c (dfs_pushdecls): Push class-local TYPE_DECLs into
    IDENTIFIER_CLASS_VALUEs.

    * cplus-typeck.c (c_expand_return): Call `expand_cleanups_to' with
    NULL argument in case the return value generated cleanups for its
    call.

    * stmt.c (expand_anon_union_decl): Fixed so that MEM anon unions
    are correctly handled.

    * cplus-decl2.c (finish_anon_union): Handle non-global static
    anonymous unions.

    * cplus-decl.c (shadow_tag): Change int variable OK to enum
    tree_code OK_CODE, remembering the value of the code we though was
    ok.  This avoids being confused when other legitimate DECLSPECS
    (such as `static') appear after one like `union ...'.

    * cplus-class.c (popclass): When popping from a class's scope,
    back to another class's scope, restore CURRENT_VTABLE_DECL only if
    we had one before.

    * cplus-decl2.c (grokfield): Push TYPE_DECL into class level as
    soon as we see it.

    * cplus-class.c (instantiate_type): In ADDR_EXPR case, complain if
    type we are instantiating to is not POINTER_TYPE.

    * cplus-decl.c (start_method): Call `preserve_data' to save the
    parameters (which were read into the maybepermanent obstack).

    * cplus-typeck2.c (digest_init): Handle case of union with
    constructor.

    * cplus-init.c (build_member_ref): Vestigial bug from change in
    representation of method lists (from list of lists to list of
    chains).

    * cplus-class.c (instantiate_type): Rewrite TREE_LIST case to use
    `next_baselink' when appropriate, and to try overloading based on
    non-member functions if that looks appropriate.

    * cplus-search.c (next_baselink): New function.  Contains code
    broken out of `build_method_call' to advance to next chain of
    FUNCTION_DECLs.

    * cplus-init.c (build_member_ref): If member ref is a reference to
    non-unique member function, return a BASELINK (which is a list of
    lists) rather than a list containing just that type's methods with
    that name.

    * cplus-init.c (resolve_member_ref): Handle uninstantiated method
    types.

    * cplus-decl.c ({start,finish}_decl): Call pushclass/popclass for
    decls which are static class members, in order to perform
    visibility computations for initializers correctly.
    * cplus-decl.c (grokvardecl): If static class member, set
    DECL_CONTEXT of the decl to the containing class type.

    * cplus-search.c (get_first_matching_virtual): Must call comptypes
    starting from first parameter, not its TREE_CHAIN, since one
    version of the function may have a this which is `*const' while
    the other does not.

    * cplus-decl.c (finish_decl): Permit static class members of
    reference type to be uninitialized in class declaration.  They
    will get initialized elsewhere, presumably.

    * cplus-method.c (dump_type_prefix): `const' and `volatile' were
    being put in the wrong places.  Type like `const *const ...' were
    being dumped as `const const *...'.

    * cplus-decl2.c (finish_file): Don't try to initialize anything
    which has ERROR_MARK_NODE in its initializer.

Thu Oct 12 02:41:34 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-init.c (resolve_member_ref): Catch case when we are in
    static member function context by reference is to (apparently)
    non-static member.

    * cplus-method.c (fndecl_as_string): Check PARMTYPES before
    chaining down, in case of syntax error.

    * cplus-init.c (do_friend): Take QUALS parameter.  Needed for
    `grokclassfn'.  Also take CTYPE instead of CNAME parameter.
    * cplus-decl.c (grokdeclarator): Caller changed.

    * cplus-init.c (do_friend): Set DECL_CONSTRUCTOR_P bit if we get a
    constructor.

    * cplus-tree.c (layout_basetypes): Don't allocate a virtual
    baseclass pointer if we can share one with a non-virtual
    baseclass.

    * tree.c (make_node): Build PARM_DECL nodes on the
    maybepermanent_obstack, not on the permanent_obstack.

    * cplus-typeck.c (build_unary_op): If addressing a reference and
    the reference is a variable, we need to check DECL_INITIAL, in
    case the variable is being initialized by a function call at top
    level.

    * cplus-decl.c (grokdeclarator): Be more careful when looking for
    function name when giving error that parameter list is random.

    * cplus-decl.c (grokdeclarator): Change handling of STATICP for
    member functions.  Eliminate variable MEMFUNC_STATICP.

    * cplus-decl.c (init_decl_processing): Don't disable profiling
    anymore.

Wed Oct 11 05:37:12 1989  Michael Tiemann  (tiemann at arkesden)

    * c plus-except.c [_JBLEN]: More systems have more ways to fail to
    define this value.  Implement yet another way to get it.

    * cplus-typeck.c (build_component_ref): Have to really check
    whether FIELD comes from a virtual baseclass.

    * cplus-init.c (is_aggr_typedef): Renamed
    `is_aggr_typedef_or_else' to `is_aggr_typedef', and gave it
    OR_ELSE parameter.  All callers changed.
    * cplus-parse.y (member_init): Call `is_aggr_typedef' with zero
    value for OR_ELSE.  We just want to know if the member looks like
    a virtual baseclass member or not.

    * cplus-method.c (build_decl_overload): Handle case where error
    has us building an overloaded name for something with a signature
    of X::f (...).  That signature is technically erroneous, but can
    arise in the face of certain syntax errors.

    * cplus-lex.c (yylex): Handling of extern language strings was
    broken.  If we were unlucky and got a file name string while
    reading a declaration, it could cause YYLVAL.TTYPE to contain the
    filename, rather than the type that was read in.  Fixed by
    assigning to YYLVAL.TTYPE after checking for possible language
    string identifier.

    * cplus-init.c (build_new): We cannot expand `new' inside of base
    or member initializers, so instead put the expansion into an
    RTL_EXPR.  CURRENT_VTABLE_DECL is ERROR_MARK_NODE in that case.
    * cplus-parse.y (.set_base_init): Set CURRENT_VTABLE_DECL to
    ERROR_MARK_NODE to indicate we are in initialization.
    * cplus-class.c (build_vfn_ref): Don't use cached vtable if
    calling function from base or member initializer.

Tue Oct 10 22:47:47 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-typeck.c (unary_complex_lvalue): Can't take pointer to
    member through virtual baseclass.
    * cplus-typeck.c (convert_for_assignment): Same change.

    * stmt.c (assign_parms): Don't let BLKmode parameter get
    ``rounded'' off its word boundary...`access_parm_map' does not
    know what to do if that should happen for an inline function.

    * cplus-decl.c (grokdeclarator): Distinguish STATICP, which has
    roughly the usual `C' meaning, from MEMFUNC_STATICP, which means
    that the declaration is a static member function.

Mon Oct  9 00:55:19 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-method.c (build_overload_name): Change naming scheme so
    that GNU calling convention (which passes objects in the stack) is
    distinct from cfront/PCC convention.

    * cplus-decl.c (push_overloaded_decl): Don't compare DECL_LANGUAGE
    of previously overloaded decl if it is not a FUNCTION_DECL.

    * cplus-decl.c (grokfndecl): Use parameter CHECK to control
    behavior of `grokclassfn' in non-constructor case (already used in
    constructor case).

    * cplus-class.c (finish_struct): Give warning if struct or union
    has no data members if PEDANTIC *or* EXTRA_WARNINGS.

    * cplus-typeck.c (convert_for_initialization): Don't forget to
    change TREE_READONLY VAR_DECLs into their constant initial value
    if they have one.

    * cplus-parse.y (.set_base_init): Change grammar to not go into
    error mode if a base initializer shows up for a non-member
    function.  Otherwise, compiler will push binding levels (in
    `start_function' and `store_parm_decls') which it will not pop,
    leaving us not at global_bindings_p at function end.

    * cplus-class.c (ideal_candidate): In the event that there is no
    ideal candidate, restore PARMS by moving value from TREE_PURPOSE
    values back into the TREE_VALUE slots.

Mon Oct  2 02:28:43 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-lex.c (cons_up_dtor_for_type): Call to `start_method'
    could yield VOID_TYPE_NODE in case of errors.  Handle that.
    * cplus-class.c (finish_struct): Caller of `cons_up_dtor_for_type'
    changed.

    * cplus-decl.c (pushtag): Don't call `pushdecl' on for tags which
    are TREE_NONLOCAL.
    * cplus-class.c (pushclass): Set TREE_NONLOCAL before calling
    `pushtag'.

Sun Oct  1 00:05:49 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-tree.h [DECL_VINDEX]: Change definition from being a
    FUNCTION_DECL to being a list of FUNCTION_DECLs, in the event that
    multiple baseclasses define the same virtual function.  This only
    affects code where DECL_VINDEX was assumed to be a FUNCTION_DECL,
    namely in cplus-decl.c (grokfndecl) and cplus-class.c
    (add_virtual_function).

    * cplus-typeck.c (convert_for_initialization): If we are
    converting to an ARRAY_TYPE, don't call `default_conversion' on an
    initializer which is also of ARRAY_TYPE.

    * cplus-decl.c (finish_decl): If FIELD_DECL is of type ARRAY_TYPE
    that has not yet been laid out, we must go through the code which
    calls `complete_array_type' for TYPE and `layout_decl' for DECL.

    * cplus-init.c (expand_aggr_init_1): See whether initializer can
    go through a type-conversion operator rather than an X(X&)
    constructor, since wel will save one constructor that way.  I.e.,
    trying to go through an X(X&) constructor may lead us to needing
    to go through a type-conversion operator, but the result of that
    conversion must still go through the original X(X&) constructor.

    * cplus-decl.c (finish_decl): For FUNCTION_DECLs with default
    argument, we build sub-FUNCTION_DECLs to catch calls to this
    function with fewer than the total number of arguments.  We set
    TREE_USED of the sub-FUNCTION_DECLs to keep GNU C++ from
    complaining about the function being when compiling with -Wall.
    We also need to set TREE_ASM_WRITTEN and DECL_INITIAL of the
    function to really ensure that GNU C++ does not spuriously
    complain about these sun-FUNCTION_DECLs.
    * cplus-decl.c (grokdeclarator): Set TREE_PUBLIC of after calling
    `grokfndecl' on all paths.

    * cplus-typeck.c (build_function_call): Set TREE_USED for
    FUNCTION_DECL if TREE_INLINE is zero.

    * cplus-decl2.c (grok_enum_decls): Move to cplus-decl.c since it
    now needs access to `struct binding_level'.
    * cplus-decl.c (grok_enum_decls): When looking for class-local
    enum tags, warning if we find them in a class binding level other
    than the current one.  It probably indicates a parse error in the
    file.

    * cplus-decl.c (lang_decode_option): Recognize new option
    -Wenum-clash, which gives warnings when enumeral types are
    used in suspect ways, such as assigning from one enumeral
    type to another.

    * cplus-typeck.c (message_2_types): Was previously called
    `error_2_types'.  Now takes argument PFN which is pointer to
    the function which will actually print the message.
    * cplus-typeck.c (convert_for_assignment): Give error for
    passing incompatible enums only if pedantic.  Otherwise, give
    warning.

    * cplus-init.c (finish_base_init): Add argument T which is the
    type for which the base initialization is being finalized.  When
    finished initializing fields which come from anonymous unions,
    call `finish_base_init' on that anonymous union, which will unmark
    interesting fields recursively.
    * cplus-decl.c (finish_function): Caller changed.

    * cplus-method.c (hack_identifier): Permit calls through
    REFERENCE_TYPE fields which overload `operator ()'.

    * cplus-cvt.c (convert): Remove warning ``assignment to virtual
    aggregate type''.

    * cplus-decl.c (finish_decl): Make sure to destroy function-local
    static objects if they had been initialized.  Set TREE_STATIC bit
    for elements of STATIC_AGGREGATES which are function-local
    objects.
    * cplus-decl2.c (finish_file): Rest of that implementation.

Sat Sep 30 20:34:52 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-typeck.c (actualparameterlist): Don't let objects with
    operator= or X(X&) constructors be passing into `...'.  If
    PEDANTIC, give error, otherwise, give warning.

    * cplus-typeck.c (convert_for_assignment): Get tougher on
    conversions to/from enumeral data types.

    * cplus-typeck.c (build_modify_expr): Make `operator=' an
    inheritable operator.

    * cplus-decl.c (push_overloaded_decl): Give error message if
    overloaded functions from different language contexts have the
    same type signature.

    * cplus-cvt.c (build_default_binary_type_conversion): If the types
    are not C++ types, then give error message saying that no type
    conversion operator exists.  Call function `typedecl_for_tag' to
    get name for error message.
    * cplus-decl.c (typedecl_for_tag): New function.  Return the
    TYPE_DECL (if any) assoicated with TAG.

    * cplus-class.c (build_functional_cast): Handle case where `A (B)'
    does not mean pass `B' to A's constructor, but rather call
    B.operator A ().

    * cplus-search.c (get_first_matching_virtual): If argument types
    differ only in their qualifiers, admit a match, but warn the user
    that this match was made.

    * cplus-lex.c (yyungetc): New function.  Give parser routines the
    ability to adjust input tokens if initial lexing was a little bit
    wrong.

    * cplus-method.c (build_overload_name): Distinguish reference
    types from non-reference types.

    * cplus-typeck.c (process_init_constructor): Give error messages
    about types of objects which cannot be initialized from an
    initializer list.

Wed Sep 27 00:22:16 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-class.c, cplus-init.c (various places): Handle cases that
    fields of struct are really local type declarations.

    * cplus-decl2.c (grokclassfn): Added new parameter CTYPE, in order
    to remove dependence on class name-class type equivalence.  This
    was done for exception handling.
    * cplus-decl.c, cplus-init.c, cplus-except.c: All callers changed.
    * cplus-lex.c (cons_up_dtor_for_type): Added parameter NAME, for
    same reason.
    * cplus-class.c (finish_struct): Caller changed.

    * cplus-decl.c (duplicate_decls): If OLDDECL's type must change,
    remove OLDDECL from STATIC_AGGREGATES if it was there.
    * cplus-decl2.c (finish_file): Handle VARS being ERROR_MARK_NODE.

    * cplus-class.c (build_method_call): When calling `build_new',
    pass BASETYPE, not NAME, as the thing to be new'd.

    * cplus-parse.y (raise_identifiers): Permit qualified names, i.e.,
    `raises List::NotFound'.
    * cplus-decl.c (grokdeclarator): Handle nested exception scopes.
    * cplus-except.c (finish_exception_decl): Ditto.
    * cplus-class.c (build_method_call): Ditto.

    * cplus-except.c (init_exception_processing): Build in `setjmp'
    and `longjmp'.

    * cplus-except.c (expand_cplus_{start,end}_exception): If the
    exception object has elements which need cleanpus, call those
    cleanups after handling the exception.

    * cplus-except.c (finish_exception_decl): Set TYPE_HAS_CONSTRUCTOR
    bit, since call to `grokdeclarator' is subverted.

    * cplus-except.c (init_exception_processing): Size of `handler'
    field in built-in `ExceptionHandler' type was too big by one.

    * cplus-init.c (build_delete): Don't call non-virtual destructor
    with first argument of zero.

    * cplus-parse.y (except_stmts): Handle default exception as last
    exception (so that fall-through does the right thing).  Also, give
    error message if multiple `default' clauses appear within an
    `except_stmt'.

    * cplus-decl.c (finish_decl): If a variable needs a cleanup, pass
    the cleanup to `expand_decl', whether or not that variable has RTL
    or not.
    * cplus-except.c (expand_start_try): Call `finish_decl' instead of
    `expand_aggr_init' to initialize the exception handler for the
    try.  Otherwise, the exception handler's destructor will not be
    called at the end of the try.

    * cplus-decl.c (store_parm_decls): Don't call `__main' from `main'
    until after the parameters have been dealt with.

Tue Sep 26 09:41:29 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-parse.y (stmt): Deal with case of TRY statement without
    corresponding EXCEPT clause.

    * cplus-decl.c (duplicate_decls): Don't call `compexcepttypes'
    until after calling `commontype', lest default parameters cause
    identical exception lists to look different.

    * cplus-except.c (end_exception_decl): New function clears
    exception declaration state.
    * cplus-parse.y (datadef): Call end_exception_decl when we are at
    the end of a declaration which could be an exception declaration.

    * cplus-class.c (modify_vtable_entry): Reenable stubbed out code
    which is used when baseclass is virtual.
    * cplus-class.c (finish_struct): When base class is virtual, check
    CLASSTYPE_VBASECLASSES using `value_member' instead of
    CLASSTYPE_ASSOC using `assoc_value'.

    * dbxout.c (dbxout_tags): Ensure that fully output types have
    their typedefs output as well.  Needed to support -fminimal-debug.

Sun Sep 24 11:22:41 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-method.c (report_type_mismatch): Don't tweak I if the
    function was FUNCTION_TYPE.  Let TTF and TTA be advanced according
    to CP->U.BAD_ARG only.

    * expr.c (expand_expr): PROTECT argument missing in call to
    `expand_delete'.
    * cplus-init.c (build_delete): Call `convert_force' instead of
    `convert' if PROTECT is 0.

    * cplus-typeck2.c (digest_init): When initializing a RECORD_TYPE
    object, call `convert_for_initialization' as a last resort.

    * cplus-tree.c (build_exception_variant): Used TREE_CHAIN for look
    when should have used TYPE_NEXT_VARIANT.

    * cplus-decl.c ({start,finish}_decl): Handle decls which are
    CLASSTYPE_DECLARED_EXCEPTION.  For `start_decl', nothing needs to
    be done.  For `finish_decl', call `finish_exception_decl'.

    * cplus-except.c (finish_exception): When user defines an
    exception, make the compiler generate that exception's constructor
    automatically.

    * cplus-typeck.c (build_binary_op_nodefault): Associate
    (((a && b) && c) && d) to ((a && b) && (c && d)) to get better
    merging of component references when possible.
    * cplus-typeck2.c (merge_component_comparisons): Permit
    non-contiguous bitfield tests if bitfields are comparisons against
    integers.

    * cplus-tree.c (layout_basetypes): Give each basetype the
    alignment it wants.

    * cplus-lex.c (yylex): Recognize >?= and <?= operators (like +=
    for min and max operators).

    * cplus-decl.c (grokdeclarator): Set TREE_PUBLIC bit of
    FUNCTION_DECLs in FIELD_CONTEXT if they are !INLINEP.

    * cplus-decl.c (finish_function): Don't pay attention to
    `current_function_returns_null' when compiling constructors.

Sat Sep 23 00:03:52 1989  Michael Tiemann  (tiemann at arkesden)

    * stmt.c (assign_parms): Take care of case where parm arrives on
    the stack, but `__builtin_saveregs' might be called.  In that
    case, get bits from stack into registers, so that
    `__builtin_saveregs' will not overwrite with garbage.
    * expr.c (expand_builtin): Modify expansion of BUILT_IN_SAVEREGS
    to protect stack args that need protecting.

    * cplus-decl.c (grokdeclarator): Never build a METHOD_TYPE if
    CTYPE is NULL_TREE.  Was doing that when declaration of illegal
    construct ``virtual friend'' was parsed.

    * cplus-parse.y (do_array:): Don't try to call `build_array_ref'
    if $3 is ERROR_MARK_NODE (cuts down on spurious error messages).

    * cplus-decl.c (grokfndecl): Move setting of DECL_VIRTUAL_P bit to
    after we know whether the function is virtual.  Remove setting
    CLASSTYPE_VSIZE.  This will be set more accurately by
    `finish_struct'.

Fri Sep 22 15:36:32 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-cvt.c (convert_to_pointer): PATH was reversed for
    computing nested virtual base accesses.

    * cplus-except.c (finish_exception): Call POPCLASS at end.

    * cplus-class.c (build_field_call): New function containing code
    broken out of `build_method_call'.  Extended to grok calls through
    fields of exception objects which overload `operator()()', or are
    otherwise callable.
    * cplus-class.c (build_method_call): Now about 100 lines shorter.

    * cplus-decl.c (grokdeclarator): Take new argument RAISES
    specifying the exceptions that a function will raise.
    * cplus-decl.c (grokfield): Implement RAISES semantics by passing
    them to `grokdeclarator'.

    * cplus-decl.c (grok{fn,var}decl): Two new functions containing
    code broken out of `grokdeclarator'.
    * cplus-decl.c (grokdeclarator): Now about 250 lines shorter.

Thu Sep 21 16:51:11 1989  Michael Tiemann  (tiemann at arkesden)

    * cplus-search.c (get_vbase_types): Sort was totally broken.
    Completely rewritten.

Wed Sep 20 00:47:36 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl2.c (finish_file): Change !defined(SDB_DEBUGGING_INFO)
    to defined(DBX_DEBUGGING_INFO).

    * cplus-class.c (finish_struct): Argument to `alloca' was off by
    9.

    * cplus-init.c (build_new): If type requires alignment >
    BITS_PER_WORD (which is what ``__builtin_new'' is supposed to
    give), then get more space and round manually.

Tue Sep 19 03:08:58 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl.c (finish_decl): Don't call `comptypes' if INIT is
    error_mark_node.

    * cplus-cvt.c (convert_to_reference): Set TREE_VOLATILE bit for
    assignment from one reference to another (for
    build_compound_expr).

    * cplus-decl2.c (finish_file): If we are compiling on Suns, bind
    local label ``_fini'' to static file cleanup function and
    ``_init'' to static file initialization function. STUBBED OUT FOR
    NOW.

    * cplus-parse.y: Put `type_quals' in 3rd operand position of a
    CALL_EXPR.  Interface to `start_function', `start_method'
    and `grokfield' changed.
    * cplus-decl.c (grokdeclarator): Get QUALS from
    TREE_OPERAND (CALL_EXPR, 2). [n.b.: First operand is
    TREE_OPERAND (CALL_EXPR, 0)].

    * cplus-tree.h (TYPE_RAISES_EXCEPTIONS): For FUNCTION_TYPE and
    METHOD_TYPE, a list of the exceptions that may be raised.
    * cplus-decl.c (duplicate_decls): Remove assumption that
    TYPE_LANG_SPECIFIC implies that type IS_AGGR_TYPE.

Mon Sep 18 14:08:02 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-class.c (add_virtual_function): If WRITE_VIRTUALS == 2,
    only set the TREE_ADDRESSABLE bit on a virtual function if the
    virtual function table is actually being output in this file.
    * cplus-decl.c (grokdeclarator): If WRITE_VIRTUALS == 2, make
    inline virtual functions TREE_PUBLIC if we are writing out this
    virtual function's virtual function table.
    * cplus-lex.c (reinit_parse_for_method): Don't clobber the above
    setting of TREE_PUBLIC for virtual functions.

    * cplus-lex.c: Process inline functions in declaration order.

Sun Sep 17 01:46:14 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-declc. (grokdeclarator,start_method,start_function): Merge
    ``extern inline'' change.

    * cplus-typeck2.c (merge_component_comparisons): New function.
    Optimizes operations on contiguous component references provided
    that operations and alignments permit.
    * cplus-typeck2.c (make_merged_ref): Subroutine of above function
    to actually get the combined references.

    * cplus-typeck2.c: New file.  Contains error-reporting
    functionality from cplus-typeck.c, and other functionality which
    could be easily moved out.

    * cplus-typeck.c (unary_complex_lvalue): Must test against
    {FUNCTION,METHOD,OFFSET}_TYPE before testing whether ARG is a
    MEMBER_REF.  If the former holds, then we have an expression like
    X::Y.  In the latter case, we have an expression like (X->*Y).

Sat Sep 16 11:31:21 1989  Michael Tiemann  (tiemann at teacake)

    * toplev.c (main): Recognize `+' options again.

    * cplus-decl.c (lang_decode_option): Implement `+e2' option, which
    writes out only virtual function tables specified in #pragma
    vtable.
    * cplus-decl2.c (finish_file): Implement semantics of `+e2'
    option.
    * cplus-lex.c (yylex): Recognize `#pragma vtable'.

    * cplus-decl2.c (finish_file): Charge time used against
    VARCONST_TIME, not PARSE_TIME.

Thu Sep 14 18:04:10 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-init.c (build_new): If FLAG_THIS_IS_VARIABLE is non-zero,
    then generate call to constructor with zero as first argument.
    Otherwise, use `expand_aggr_init' to initialize the storage
    returned from whatever storage allocator was called.
    Initialization of virtual baseclasses simplified.  Memory
    management made more complex (though more general) because we may
    have `new' expressions not being evaluated until `finish_file' is
    called.
    * cplus-decl2.c (finish_file): Handle a `new' expreesion at top
    level.

    * cplus-decl.c (finish_function): Change call from `build_x_new'
    to `build_new'.
    * cplus-init.c (build_x_new): Deleted.

    * cplus-init.c (build_new): Give error if arguments are given to a
    `new' expression for which no constructor is defined.

    * cplus-decl.c (decode_lang_option): Use option table from
    toplev.c to decode -f options.

    * cplus-method.c (flush_repeats,build_overload_name): Change
    naming convention to avoid ambiguous names if type index or number
    of repeats is more than nine.

    * cplus-except.c (init_exception_processing): Use <setjmp.h> to
    find length of setjmp buffer.

Wed Sep 13 05:32:50 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl.c (start_method): Set TREE_INLINE bit if
    FLAG_DEFAULT_INLINE is nonzero.
    * cplus-decl.c (lang_decode_option): Recognize -fdefault-inline.

    * cplus-init.c (do_friend): Call `pushdecl_top_level' instead of
    `pushdecl'.

    * cplus-decl.c (start_method): Only need to copy node if it is not
    a friend.
    * cplus-decl.c (finish_method): In that case, return
    VOID_TYPE_NODE if the method was really a friend, but save it to
    CLASSTYPE_INLINE_FRIENDS so it can be processed properly later.
    It would be nice to have an obstack for this list so it could be
    freed at the end of this class's processing.

Tue Sep 12 05:22:03 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl.c (start_function): Make C++ FUNCTION_DECL inherit
    DECL_ASSEMBLER_NAME from old C FUNCTION_DECL if their types are
    identical.  This makes C<->C++ calls *much* easier to deal with.

    * cplus-decl.c (xref_tag): Don't set CLASSTYPE_DECLARED_CLASS bit
    if REF is CURRENT_CLASS_TYPE (??? or on the CURRENT_CLASS_STACK).

    * cplus-search.c (lookup_field_1): Give the user the virtual
    function table field if the name is `_vptr'.
    * cplus-decl2.c (grokfield): Don't let user declare anything with
    that name.

    * cplus-cvt.c (build_type_conversion): If we are trying to convert
    to type `void*' and no conversion to ptr_type_node exists, but a
    some other pointer conversion for TYPE exists, then convert to
    that pointer type, unless there is more than one such conversion,
    in which case return ERROR_MARK_NODE.  The caller will emit an
    error message in that case.  All callers changed.
    * cplus-cvt.c (convert_to_{integer,real,pointer}): Removed `saving
    throw' case which would try converting aggregate to a default type
    if requested conversion did not succeed.  `build_type_conversion'
    knows how to perform such `saving throws'.
    * cplus-tree.h (lang_type): New field `ptr_type_conversion'.
    * cplus-decl.c (grokdeclarator): Record whether a type has a
    type conversion operator here.
    * cplus-class.c (finish_struct): Set up `ptr_type_conversion'.
    Also, don't need to trudge through all methods to find out there
    are no type conversion methods.

Mon Sep 11 10:45:01 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-class.c (finish_struct): If we must cons up a destructor
    for a type, and METHOD_VEC was 0, set TREE_VEC_LENGTH (METHOD_VEC)
    to 1 after allocating METHOD_VEC.

    * cplus-class.c (finish_struct): Finish processing METHOD_VEC
    before making other calls out which may call `hash_tree_chain'.

    * cplus-class.c (finish_struct): Add BASE_LAYOUT_DECL to eliminate
    need for callback in stor-layout.c.

    * cplus-typeck.c (build_binary_op): Special case situation where
    we compare ARG1 with INTEGER_ZERO_NODE and ARG1 is of aggregate
    type.  This is what comes from `truthvalue_conversion'.

    * cplus-cvt.c (build_type_conversion): New argument CODE says for
    what purpose the conversion is taking place.  Important ones are
    truthvalue operations, which permit us to convert to different
    types then the ones we asked for.  All callers changed.
    * cplus-cvt.c (build_default_{binary,unary}_type_conversion): Same
    change.  All callers changed.

    * cplus-class.c (finish_{base_}struct): Set
    TYPE_NEEDS_CONSTRUCTING bits when basetype or member type needs
    constructing.

    * cplus-search.c (compute_visibility): Use TYPE_MAIN_VARIANT to
    see if field is public member of private baseclass.

    * cplus-init.c (expand_aggr_init_1): When bad arguments were
    passed to constructors for base initialization, only half the
    error message would appear.

    * Makefile: Remove dependencies on unexec.c and unex-addr.c.

    * cplus-decl.c (push_overloaded_decl): Can't use `value_member' to
    find previously declared function.  Use DECL_NAME of function
    instead, since that must be unique (as a type signature/name
    combination).

    * cplus-lex.c (yylex): typo in assert macro.
    * cplus-cvt.c (convert_to_nonzero_pointer): Ditto

    * All GNU C++ files: implement initialized constant fields.  Make
    them non-static, non-addressable VAR_DECLs.

Sun Sep 10 09:19:22 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-method.c (build_opfncall): Remove METHOD_REF case.
    * tree.def: Remove definition of METHOD_REF.

    * cplus-decl.c (finish_decl): If a static member needs
    constructing, but it does not have an initializer, make it
    TREE_EXTERNAL.
    * cplus-decl2.c (grokfield): Set DECL_IN_AGGR_P before calling
    `finish_decl' for VAR_DECLs.

    * cplus-parse.y (forhead.2): New rule to keep GNU C++ gives better
    error handling when multiple variables are declared in the first
    part of a `for' stmt.

    * cplus-lex.c (finish_method): Handle case when `start_method'
    returns VOID_TYPE_NODE (two definitions of the same method in the
    same class.

    * cplus-decl.c (grok_op_properties): Make static operators (other
    than new and delete) trigger error messages.  If operator new or
    delete has no arguments (due to syntax errors), rebuild their
    types.  They have the right names, because `build_operator_fnname'
    knows how to do that.

    * stor-layout.c (make_{un}signed_type): Cache size nodes for
    pointers, functions, and methods.
    * stor-layout.c (layout_type): Use cached types.

    * cplus-decl{2}.c: Use `hash_tree_chain' instead of `tree_cons'
    where possible.

    * cplus-decl.c (expand_static_init): If variable has already been
    initialized, give complaint, but don't store the initializer.
    That way we don't have to preserve it on the temporary obstack.

    * cplus-parse.y (identifier_or_opname): Accept new C++ destructor
    syntax, which is effectively "scoped_identifier '~' identifier".
    * cplus-class.c (build_scoped_method_call): Accept calls using new
    C++ destructor syntax here.
    * cplus-class.c (build_method_call): Reject calls through here
    which don't use a leading `scoped_identifier'.

    * cplus-init.c (build_new): Don't permit arrays of `void'.  Better
    error message emitted for newing `void'.

    * cplus-typeck.c (build_conditional_expr): Don't call
    `default_conversion' on the arms of the conditional if both are of
    the same enumeral type.  Otherwise, if EXTRA_WARNINGS, give
    warning if enumeral type appears in either (or both) arm(s) of the
    conditional.

    * cplus-cvt.c (build_type_conversion): Don't convert from `int' to
    `void*'.  Don't convert a `void*' to an `int'.

    * cplus-decl.c (xref_tag): If we get an old reference to a C
    struct name, and we are in C++ langauge context, give it a
    TYPE_DECL.

    * cplus-class.c (build_method_call): Don't call
    `default_conversion' on MEMBER_REFs because they might be enums.
    Instead, call `resolve_member_ref', and then if the type is
    something we would rather convert before calling
    compute_conversion_costs, convert that.

    * cplus-init.c: Set TREE_VOLATILE bit after all
    ``build (CALL_EXPR, ...)'' calls.

    * cplus-init.c (expand_vec_init): If at global binding level,
    return a TREE_VEC which contains the initialization parameters for
    the vector.  `expand_vec_init' is no longer static.
    * cplus-decl.c (finish_decl): Handle INIT being result of
    `expand_vec_init' at top-level.
    * cplus-decl2.c (finish_file): Ditto.

Sat Sep  9 12:44:48 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-class.c (finish_struct): Move error message about static
    members in unions from stor-layout.c to here.

    * varasm.c, stor-layout.c: Merged with GCC.
    * cplus-class.c (finish_struct): Use special FIELD_DECL in
    TYPE_FIELDS of T before calling `layout_type' to have effect of
    passing basetype layout information to `layout_record'.

    * cplus-typeck.c (build_c_cast): Typo in call to
    cleanup_after_call.

Fri Sep  8 11:16:01 1989  Michael Tiemann  (tiemann at teacake)

    * All GNU C++ files: replaced calls to `abort' with assertion
    macros where appropriate.  Also removed some unneccessary tests
    against ERROR_MARK_NODE in various function calls.

    * cplus-lex.c (check_newline): Changed to take NEXTCHAR into
    account.

Thu Sep  7 06:15:56 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl.c (store_parm_decls): Change where
    DECL_REFERENCE_SLOT is initialized.  Eliminate a second loop
    through the parms.

    * cplus-method.c (hack_identifier): Don't need to test against
    FUNCTION_DECL before testing if the TREE_TYPE is REFERENCE_TYPE.

    * cplus-lex.c (yylex): If reading `0' or `1', return
    INTEGER_ZERO_NODE or INTEGER_ONE_NODE respectively.
    * cplus-decl.c (build_enumerator): If we got one of these two
    as a value, make a copy.

    * tree.c,cplus-lex.c,cplus-class.c,cplus-search.c
    [GATHER_STATISTICS]: Now only gather statistics if this macro is
    defined.

    * tree.c (make_node,build_int_2,tree_cons,build_tree_list): Merge
    Bryan Boreham's ``deluxe'' memory profiling code.

    * cplus-decl.c (finish_decl): Only complain about uninitialized
    refs and consts if there is no constructor for the type.  If there
    is a constructor, then that constructor should say whether it did
    not initializer certain fields or not.

    * cplus-init.c (expand_aggr_init): When initializing, nothing is
    `const'.

    * cplus-decl.c (store_parm_decls): No need to call
    expand_decl_init on a PARM_DECL.  In fact, now it is wrong.

    * tree.h: rearranged tree_decl layout and defined
    tree_function_decl type for FUNCTION_DECLs.  Now space
    requirements for FUNCTION_DECLs do not impose on other kinds of
    _DECL nodes.  Also, PARM_DECL nodes use less than a full decl
    node's worth of space.
    * toplev.c (rest_of_decl_compilation): Don't permit ASMSPEC to
    appliy to PARM_DECL nodes.
    * varasm.c (make_decl_rtl): Abort if called for a PARM_DECL node.
    * print-tree.c (dump): PARM_DECL nodes are not full.
    FUNCTION_DECL nodes have more fields then regular _DECLs now.
    * tree.c (make_node): Use TREE_CODE_LENGTH when allocating _DECL
    nodes.  Also, don't set DECL_SOURCE_* for PARM_DECL nodes.
    Instead, set their DECL_CONTEXT to CURRENT_FUNCTION_DECL.
    * tree.c (build_decl): Don't set DECL_ASSEMBLER_NAME for PARM_DECL
    nodes.
    * cplus-decl.c (start_decl): Don't not push DECL if DECL is a
    PARM_DECL.

    * cplus-lex.c (yylex): Remove tests about whether we *really* saw
    a keyword or not.  Instead, use `init_lex' to do most of the work
    for us (since lang_c's reserved word set is a subset of
    lang_cplusplus).

    * cplus-decl.c,cplus-decl2.c,cplus-typeck.c,cplus-class.c,
    cplus-lex.c, cplus-method.c: change tests of the form
    (TREE_VALUE (t) == void_type_node) to (t == void_list_node).

    * cplus-decl2.c (grokopexpr): Added argument CTYPE to help
    distinguish whether operators NEW and DELETE belong to a class, or
    are the global operators NEW and DELETE.
    * cplus-decl.c (grokdeclarator): Caller changed.
    * cplus-method.c (hack_operator): Caller changed.

Wed Sep  6 10:29:45 1989  Michael Tiemann  (tiemann at teacake)

    * dbxout.c (dbxout_type): Handle static member functions.

    * cplus-typeck.c (c_expand_return): Change test from
    TYPE_NEEDS_CONSTRUCTING to TYPE_NEEDS_CONSTRUCTOR to see whether
    `expand_aggr_init' must be called.

    * cplus-decl2.c (grokfield): Use `digest_init' to digest
    CONSTRUCTOR initializers of fields.

    * cplus-decl.c (grokdeclarator): Permit ARRAY_TYPE field decls to
    get their types from their initializer (if they were incomplete).

    * cplus-lex.c (build_operator_fnname): If there is more than one
    parameter to NEW_EXPR, then it is `__user_new'.

    * cplus-decl.c (store_parm_decls): Remove code to deal with case
    that function was declared without prototypes.  It is never
    executed.

    * cplus-typeck.c (unary_complex_lvalue): Handle (x->*y) as an
    lvalue.

    * cplus-decl.c (start_decl): Put in check that temporary obstack
    starts out empty when we start parsing an initializer.
    * cplus-decl.c (expand_static_init): If the initializer was read
    into the temporary obstack, preserve all space that it used.  I
    don't think it is safe to always read the initializer into the
    permanent_obstack and then free the space if it doesn't look
    interesting, because types may be created dynamically as a result
    of reading it in (such as array types), and we don't want them to
    get freed.

    * cplus-decl.c (finish_decl): Don't set DECL_ASSEMBLER_NAME of the
    decl to ASMSPEC if ASMSPEC is 0.

    * cplus-decl.c (finish_function): Set named_label_uses to
    NULL_TREE at end of function.

Tue Sep  5 05:24:18 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-except.c: New file.  Implements exception handling scheme
    designed by Michael Powell.

    * cplus-method.c (build_overload_name): Overload constructor names
    as '__' instead of whatever their original name was.
    * cplus-method.c (build_decl_overload): Distinguish constructors
    from other kinds of member functions.
    * cplus-decl2.c (grokclassfn): Call changed to
    `build_decl_overload' to take this into account.

    * cplus-decl.c (duplicate_decls): Don't crash if NEWDECL is a
    VAR_DECL, and there is an old VAR_DECL on the chain.  Happens for
    strange parse errors.

Mon Sep  4 01:36:07 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-decl2.c: New file.  Contains functions which used to be
    defined in cplus-decl.c, but could be easily broken out. Also
    moved some functions out of cplus-tree.c which did not really
    belong there, but were put there to make compilation less painful.

    * cplus-class.c (build_method_call): Use ERR_NAME in more places
    when printing error messages.

    * cplus-decl.c (grokdeclarator): Special case NEW_EXPR and
    DELETE_EXPR when grokking an OP_IDENTIFIER.  Make these guys
    static member functions.  Callers in cplus-init.c changed.
    * cplus-tree.c (coerce_new_type,coerce_delete_type): Force the
    type of `operator new' and `operator delete' to wind up with the
    right types.
    * cplus-lex.c (build_operator_fnname): Handle `operator new' and
    `operator delete' correctly, warning when the wrong number of
    parameters show up.

    * expr.c (expand_expr): Add NEW_EXPR to the list of tree codes
    for which INIT_EXPR and MODIFY_EXPR don't need to deal with
    noncopied_parts.

    * cplus-class.c (finish_struct): Initialize TREE_PURPOSE of
    TYPE_NONCOPIED_PARTS to the virtual function table for the type.

    * cplus-cvt.c (build_type_conversion_1): Compiler was getting into
    infinite recursion when asked to convert something from its own
    type to its own type.

    * cplus-parse.y: Added RERAISE statement.
    * cplus-lex.c: Added __reraise keyword.

    * cplus-cvt.c (build_type_conversion): Build type conversions to
    type variants (i.e., given `operator char * ()', convert to a
    `const char *').

    * dbxout.c (dbxout_tags): Callback to language-specific files to
    see whether a type should actually be output.
    * dbxout.c (dbxout_symbol): Same change.
    * cplus-tree.c (lang_output_debug_info): New function.
    * cplus-decl.c (finish_function): Memoize information for
    lang_output_debug_info.

    * Merged latest changes from Bryan Boreham for incremental
    compilation via dumping.

    * cplus-parse.y: Recognize `::new' and `::delete'.
    * cplus-init.c (build_new): Handle `::new' by new interpretation
    of USER_PARMS.  Only callers in cplus-parse.y needed changing.
    * cplus-init.c (build_{x_}delete): Handle `::delete' by accepting
    new argument USE_GLOBAL_DELETE.  All callers changed.

Sun Sep  3 12:42:38 1989  Michael Tiemann  (tiemann at teacake)

    * expr.c (expand_cleanups_to): New function.
    * cplus-init.c (expand_cplus_expr_stmt): Call it after all is said
    and done.

    * expr.c (expand_expr): When encountering a NEW_EXPR, it is
    possible that the NEW_EXPR did not know (when it was built) what
    its cleanup needed to be.  If its cleanup is 0, try building one
    if a new temporary was built for it.

    * cplus-decl.c (duplicate_decls): Warn if function type qualifiers
    don't match only if PEDANTIC (following change made by rms).

    * cplus-typeck.c (build_function_call): If pedantic, don't permit
    `main' to be called.

    * cplus-typeck.c (convert_for_assignment): Don't let ints
    convert to enums.

    * cplus-decl.c (start_function): Ensure that `main' is
    always declared to return an integer type.
    * cplus-decl.c (finish_function): Make it so that `main' always
    returns 0 by default.

    * cplus-decl.c (grokdeclarator): Make it now an error to specify
    return types for constructors and destructors.

    * cplus-typeck.c (comp_target_{parms,types}): Loosen up to permit
    contravariance violations, though not without warning.

    * cplus-method.c (build_overload_name): Change from old
    overloading scheme to one more or less compatible with type-safe
    linkage scheme proposed in Stroustrup's 1988 USENIX paper.

Sat Sep  2 09:16:01 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-typeck.c (convert_for_initialization): Permit
    initialization of reference from incomplete type: that type will
    be converted to REFERENCE_TYPE, and that is just as good as a
    pointer to incomplete type.

    * cplus-decl.c (finish_decl): Handle case of static reference
    initialized from non-constant initializer.  Break out code to
    initialize static variables as function `expand_static_init'.

    * cplus-decl.c (finish_decl): Don't call constructors on external
    variables.

    * integrate.c (copy_for_inline): Canonicalize PLUS expressions so
    that CONST_INTs appear on the right, and `FRAME_POINTER_RTX'
    and/or `ARG_POINTER_RTX' on the left.
    * integrate.c (copy_rtx_and_substitute): Take advantage of this
    fact and test fewer things while integrating.

    * cplus-typeck.c (c_expand_return): Try to get away with not
    issuing a call to `use_variable' for the DECL_RESULT of the
    function.  If that fails, calling it only if
    `any_pending_cleanups' returns nonzero.

    * cplus-init.c (expand_recursive_init_1): Handle multi-demensional
    arrays which need constructing.
    * cplus-init.c (expand_vec_init): Handle multi-demensional arrays.
    Say sorry if we try to use an explicit initializer in that case,
    however.

    * cplus-parse.y: Permit the integer zero to be deleted (though who
    would want to?).

    * varasm.c (make_function_rtl): Replace call to lang_rtl_name with
    use of DECL_ASSEMBLER_NAME.
    * cplus-decl.c (lang_rtl_name): Removed.

    * cplus-decl.c (grokclassfn): Set DECL_ASSEMBLER_NAME after
    changing DECL_NAME.
    * cplus-init.c (do_friend): Ditto.

    * cplus-decl.c (start_function): If CURRENT_FUNCTION_DECL is a
    destructor, set up DESTRUCTOR_LABEL.
    * cplus-decl.c (finish_function): If DESTRUCTOR_LABEL is nonzero,
    expand just before calling base destructors.
    * cplus-typeck.c (c_expand_return): If DESTRUCTOR_LABEL is
    nonzero, jump there instead of just expanding the return.

    * collect.c (process): Change from
    ([e-mail]) to skip auxiliary entries.

    * All GNU C++ files merged from 1.35.97+ to 1.35.98.

    * cplus-decl.c (define_label): If a newly declared variable in the
    label's binding contour will need a cleanup, it must live in a new
    binding contour.
    * cplus-decl.c (define_case_label): New function.  Same goes for
    case labels.
    * cplus-parse.y (stmt): Call `define_case_label' for CASE
    statements.

    * cplus-decl.c (lookup_label): Record in variable NAMED_LABEL_USES
    for each label the variables currently in scope at the use of the
    label.
    * cplus-decl.c (define_label): Give error message if jump to label
    crosses variable initialization in the current scope.

    * cplus-decl.c (struct binding_level): Change field
    `more_cleanups_ok' from char to bitfield.  Added field
    `have_cleanups'.  Change other fields to bitfields so that
    `struct binding_level' fits in 7 words, which can be
    malloc'd in total of 32 bytes.
    * cplus-decl.c (PUSH_BINDING_LEVEL,maybe_build_cleanup):
    Initialize and set field `have_cleanups'.
    * cplus-decl.c (expand_label): Set `more_cleanups_ok' to zero when
    we cross a label.

    * stmt.c (struct stack_block): Added field `initialized_decls_p'
    for blocks which need their decls expanded before used.
    * stmt.c (expand_decl{_init}): Set field initialized_decls_p when
    appropriate.

Fri Sep  1 04:29:44 1989  Michael Tiemann  (tiemann at teacake)

    * Exception handling constructs recognized (but nothing working).

    * cplus-decl.c (init_decl_processing): Call `set_identifier_size'
    with a length, not a number of bytes.

    * cplus-class.c (build_class_init_list): Braino.

    * cplus-init.c (expand_aggr_init_1): Reinitialize virtual base
    class virtual function tables if they are set to wrong values by
    their constructors.
    * cplus-init.c (expand_aggr_init): Initialize virtual base class
    virtual function tables if they are not set any other way.

    * cplus-class.c (finish_struct): Use CLASSTYPE_VSIZE instead of
    TYPE_VIRTUAL_P to determine whether a particular class has virtual
    functions which belong in its vtable.  A type can be
    TYPE_VIRTUAL_P, meaning that *somewhere* it relies on virtual
    functions, but CLASSTYPE_VSIZE could be zero, meaning that it
    itself may not even have a virtual function table pointer.
    * cplus-decl.c (finish_file): Same changes.
    * cplus-decl.c (setup_vtbl_ptr): Same changes.
    * dbxout.c (dbxout_type): Same changes.
    * cplus-tree.c (layout_basetypes): Same changes.

    * cplus-class.c (finish_base_struct): Return 0 if all virtual
    functions come only from virtual baseclasses.  Also, do not put
    into VFIELDS those fields which come from virtual baseclasses.
    * cplus-class.c (modify_vtable_entry): Instead, run through by
    hand the virtual baseclasses whose virtual function tables need to
    be modified.  This means really using exactly the right
    associations for both base, context, and derived types.
    * cplus-class.c (prepare_fresh_vtable): Change parameter TYPE to
    CONTEXT_ASSSOC.  All callers changed.

Thu Aug 31 08:17:45 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-class.c (finish_struct): Test MAX_HAS_VIRTUAL, not
    HAS_VIRTUAL to assign TYPE_VIRTUAL_P (T).

    * integrate.c (save_for_inline): Add new variable
    PARM_INITIALIZATION which is nonzero during parameter
    initialization (either from the stack or registers).
    * integrate.c (copy_for_inline): Only zero TREE_READONLY of parm
    if PARM_INITIALIZATION is zero.
    * integrate.c (expand_inline_function): Back out Aug 30
    TREE_INLINE change for PARM_DECLs.
    * cplus-decl.c, cplus-typeck.c: Ditto.

    * cplus-decl.c (finish_decl): Take into account case where static
    variable must be initialized ``by hand''.

    * cplus-typeck.c (store_init_value): Return VALUE if
    initialization could not be trivially performed for static
    variable.  Otherwise return NULL_TREE.

    * cplus-decl.c (get_temp_name): Add parameter STATICP.  All
    callers changed.

    * integrate.c (copy_rtx_and_substitute): Significantly simplify
    PLUS and MEM case after finding out that code from tList.cc could
    break the complex cases on Sparc.  Net effect: maybe more work for
    optimizer in later passes, and maybe more space occupied by inline
    insns during compilation.

    * expr.c (store_one_arg): Add test to see if we can avoid calling
    convert_units if possible.

Wed Aug 30 04:01:15 1989  Michael Tiemann  (tiemann at teacake)

    * toplev.c (main): Change +e[01] to -f+e[01], and move to
    lang_decode_option.
    * cplus-decl.c (lang_decode_option): Incorporate new flags.

    * integrate.c (copy_rtx_and_substitute): Don't build a SUBREG of a
    CONST_INT.

    * integrate.c (expand_inline_function): Change test of FORMAL from
    TREE_READONLY to TREE_INLINE.
    * cplus-typeck.c (build_modify_expr,build_unary_op): When
    modifying a PARM_DECL, set TREE_INLINE to 0.
    * cplus-decl.c (store_parm_decls): Set TREE_INLINE of PARM_DECL to
    1.

    * cplus-decl.c (finish_function): When finishing constructors, if
    simple case holds (no cleanups), just store CURRENT_CLASS_DECL
    into the DECL_RESULT of FNDECL and fall through.

    * integrate.c (expand_inline_function): Don't emit
    NOTE_INSN_DELETED notes.

    * cplus-parse.y (compstmt): Only save binding contour information
    if there actually were decls.

    * cplus-decl.c (finish_file): Argument LINENO was missing in calls
    to finish_function.

Tue Aug 29 23:03:17 1989  Michael Tiemann  (tiemann at teacake)

    * cplus-typeck.c (unary_complex_lvalue): Treat INIT_EXPR like
    MODIFY_EXPR.  Also, handle WITH_CLEANUP_EXPR case.

    * expr.c (expand_expr): Brainos in WITH_CLEANUP_EXPR case.

    * cplus-cvt.c (build_up_reference): Handle case where ARG is a
    WITH_CLEANUP_EXPR.

    * stmt.c (expand_function_end): *Don't* set REG_FUNCTION_VALUE_P.

    * tree.def [NEW_EXPR]: Change from 2 arguments to 3.  Third
    argument, if non-NULL, is cleanup expression to run after the
    new'd expression is used.  All users of NEW_EXPR changed.

Sun Aug 27 01:13:09 1989  Michael Tiemann  (tiemann at hobbes.ai.mit.edu)

    * stor-layout.c (layout_basetypes): Move from this file.
    * cplus-tree.c (layout_basetypes): To this one.

    * make-links.g++ (borrowed_files): typeclass.h is now a
    borrowed file.

    * cplus-decl.c (cleanup_after_call): New function.
    * cplus-typeck.c (build_compound_expr): Call it if neccesary.
    * cplus-typeck.c (build_c_cast): Ditto.
    * cplus-init.c (expand_cplus_expr_stmt): Ditto.
    * expr.c (expand_call): Remove code to allocate destructable stack
    slot if function return value is not used.

    * cplus-decl.c (init_decl_processing): `built_in_vec_delete' is
    NOT_BUILT_IN.
    * expr.c (expand_builtin): Don't try to expand EXPAND_VEC_DELETE.

    * cplus-init.c (build_vec_delete): Build the vector delete here;
    don't make a call to `__builtin_vec_delete'.

    * expr.c (expand_expr): Merge INIT_EXPR and MODIFY_EXPR.
    * expr.c (init_noncopied_parts): New function.

    * gcc.c: Merged completely.  Use GCC from standard distribution.

Sat Aug 26 10:38:14 1989  Michael Tiemann  (tiemann at hobbes.ai.mit.edu)

    * cplus-typeck.c (build_binary_op): Perform type instantiation if
    necessary.

    * cplus-class.c (instantiate_type,build_instantiated_decl): Change
    "type instantiation" to "overload" in various error messages.
    * cplus-class.c (instantiate_type): Also fix error message to
    report overload resolution failure only if function has more than
    one type signature declared.

    * cplus-class.c (instantiate_type): Call `mark_addressable' on
    result of instantiating something for an ADDR_EXPR.

    * 1.35.96 to 1.35.97+ changes:
    * Makefile: Change name of `cplus-parse.tab.*' to `cplus-tab.*'.
    * cplus-lex.c: Change #includes to reflect this.
    * cplus-decl.c: All merged except CURRENT_EXTERN_INLINE.
    * toplev.c: Changes for extern inlines not merged.

    * cplus-decl.c (finish_file): Reset FNNAME from DECL_NAME of the
    current function, since `start_function' may cause it to change if
    overloaded.  Also, push into C language context during the
    generation of file-level initializer/cleanup functions, since we
    don't want the extra-long names that overloading will give us.

    * cplus-decl.c,cplus-class.c,cplus-search.c: #include "obstack.h"
    instead of "cplus-obstack.h".

    * gnulib3.c: New file.  Provides initialization and cleanup
    services for GNU C++.  This should obviate the need for crt0.c.
    * crt1.c: Changed completely for new initialization/cleanup model.
    * cplus-decl.c (store_parm_decls): Put in special hooks to call
    `__main' from `main' for such purposes.

Thu Aug 24 02:11:42 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-lex.c (check_newline): Only call unexec #ifndef
    DONT_HAVE_UNEXEC.

    * cplus-lex.c (reinit_parse_for_method)[USG]: If the buffer given
    to setvbuf is shorter than eight bytes long, setvbuf will (in
    violation of its man page) ignore the buffer and call malloc to
    get a bigger one.  Fixed.

    * cplus-typeck.c (comp_target_types): Permit converting from a T**
    to a T** which has different qualifiers.

    * gcc.c (collect_spec): Changes for sun386.
    * collect.c: Ditto.
    * config.g++: Ditto.

    * cplus-parse.y (primary): Handle case where unfound
    identifier comes from base class during class declaration.

    * cplus-init.c (build_member_ref): Handle uses of class-local
    enums and static members before type is completed.

    * cplus-decl.c (pushdecl_class_level): Put enums and static
    members into class scope as soon as they are seen.
    * cplus-decl.c (poplevel_class): Make sure to take them out upon
    leaving scope.

    * cplus-lex.c (build_lang_field_decl): Take new argument CODE to
    say what kind of decl to build.
    * cplus-decl.c,cplus-parse.y: All callers changed.
    * cplus-decl.c (grok_enum_decls): Call `build_lang_field_decl'
    instead of `build_lang_decl'.  Saves memory.
    * cplus-decl.c (grokdeclarator): Same change for VAR_DECLs local
    to structs.

    * cplus-typeck.c (build_modify_expr): Fix logic so that when
    assigning to `this', the error message about not being within a
    constructor or destructor is only emitted at the appropriate time.

    * cplus-tree.h [OPERATOR_NEW_FORMAT,OPERATOR_DELETE_FORMAT]:
    Define these.
    * cplus-method.c (build_opfncall): Use them.

    * cplus-tree.h [OPERATOR_MODIFY_FORMAT,OPERATOR_MODIFY_LENGTH,
    OPERATOR_CALL_FORMAT,OPERATOR_CALL_LENGTH,OPERATOR_ARRAY_FORMAT,
    OPERATOR_ARRAY_LENGTH]
    Define these.
    * cplus-decl.c (grok_op_properties): Use them.
    * cplus-init.c (add_friends): Ditto.

    * cplus-tree.h [VTBL_PTR_TYPE]: Define this.
    * cplus-decl.c (init_decl_processing): Use it.

    * cplus-tree.h [OPERATOR_METHOD_FORMAT,OPERATOR_METHOD_LENGTH]:
    Define these.
    * cplus-class.c (build_method_call): Use them.

    * cplus-class.c (compute_conversion_costs): Fix typo which would
    cause error message to be generated for calling a const member
    function with a non-const object.

    * Aug 24 03:10 g++.xtar.Z on ~ftp/pub

    * cplus-init.c (build_new): Braino involving -fthis-is-variable
    removed.

Wed Aug 23 00:12:29 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (finish_decl): Cannot forever remove READONLY
    attribute from decl needing initialization.

    * cplus-method.c (report_type_mismatch): Report error if calling
    non-const member function with const object.

    * cplus-class.c (convert_harshness,build_method_call): Finish
    implementing code to catch calls to non-const member functions
    with const objects.

    * cplus-class.c (build_method_call): No longer need to get to
    TYPE_MAIN_VARIANT for type information, such as TYPE_NEEDS_....

    * cplus-class.c (finish_struct): Set flags in all type variants.
    * cplus-parse.y (various places): Ditto.

    * integrate.c (expand_inline_function): No longer call abort if
    TREE_TYPE (arg) != TREE_TYPE (formal) for BLKmode parameter.  This
    can happen when TREE_TYPE (formal) == ERROR_MARK_NODE.

Tue Aug 22 09:06:32 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (ideal_candidate): Use `function' member instead
    of `u.field' member of candidates.  The former is always properly
    set up, whereas the latter is set to 0 if the function used is a
    non-member function.

    * cplus-decl.c (groktypefield): Handle case where IDENTIFIER_NODE
    comes in which is not an aggregate type name.

    * cplus-method.c (hack_operator): Return ERROR_MARK_NODE if
    operator name is missing.
    * cplus-parse.y: Callers changed to deal with this.

    * cplus-search.c (various places): Most calls to
    `error_with_aggr_type' were wrong, leading to backward error
    messages (such as `member `A' not found for class `memfunc').
    Changed back to call `error' with appropriate parameters.

    * cplus-search.c (lookup_fnfields): Braino in printing error
    message: TREE_VALUE (entry) is a BASELINK (a TREE_LIST of
    TREE_LISTs), not a TREE_LIST.

    * cplus-decl.c (grokdeclarator): Handle missing operator name for
    for OP_IDENTIFIER case.

    * cplus-init.c (finish_base_init): If the vtable installed by the
    constructor was not the right one, fix after call to base
    constructor, before derived initialization.

    * cplus-decl.c (store_parm_decls): New parm PRESERVE is nonzero if
    we should preserve the data containing the function parameters.
    This is normally done for inline functions, but also needs to be
    done for constructors of classes which use virtual baseclasses.
    * cplus-decl.c (finish_function): Don't set DECL_ARGUMENTS (FNDECL)
    to zero if above condition holds.
    * cplus-decl.c, cplus-parse.y: all callers of store_parm_decls
    modified.

    * cplus-tree.c (hash_tree_chain): New function.  Simplified
    version of hash_tree_cons.
    * cplus-parse.y (declmods): Use `hash_tree_chain' to build up
    lists which are not destroyed during parsing.  They can be reused
    throughout the rest of the parse.

Mon Aug 21 09:51:47 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-init.c (expand_aggr_init_1): Replace PARM_DECL rtl's with
    actual values to parameters.

    * cplus-init.c (expand_aggr_vbase_init): Only try initializing
    base classes here if FNDECL is nonzero.
    * cplus-init.c (expand_aggr_init_1): Try initializing them here in
    that case instead.

    * cplus-decl.c (finish_decl): We can initialize a const& from a
    const int, etc.

    * cplus-init.c (expand_vec_delete): Only warn about ignored array
    size expressions if EXTRA_WARNINGS.

    * cplus-init.c (build_new): Don't forget to allocate space for
    vectors.

    * cplus-init.c (add_friend): If the friend is not of METHOD_TYPE,
    set CTYPE = ERROR_MARK_NODE.  This prevents false friend matches
    due to fact that `is_friend' assumes that if CURRENT_CLASS_TYPE ==
    TREE_PURPOSE (friends), that a class-match has occured.

    * stmt.c (expand_end_bindings): Don't let cleanups affect ({...})
    constructs.

    * cplus-decl.c (finish_decl): When initializing one reference from
    another, make sure that we wrap the initializer in a SAVE_EXPR if
    it is TREE_VOLATILE.

    * cplus-class.c (compute_conversion_costs): Check that FORMAL_TYPE
    is not ERROR_MARK_NODE.

    * tree.h (tree_type): Delete unused field `parse_info'.

    * cplus-decl.c (setup_vtbl_ptr): Add tests for OPTIMIZE and that
    CURRENT_FUNCTION_DECL is not DECL_STATIC_FUNCTION_P.

Sun Aug 20 12:09:30 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c,cplus-typeck.c (various places): Check for
    CONST_DECL in addition to TREE_READONLY VAR_DECLs when needing
    constants for various purposes.

Sat Aug 19 12:27:41 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (build_method_call): Handle case where
    INSTANCE_PTR is integer_zerop.  This can happen with casts like
    { return ((Object*)0)->Object::IsA(); }

Fri Aug 18 01:14:02 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (build_method_call): Complain about using abstract
    function only if INSTANCE is of known abstract type.

    * cplus-class.c (add_method): Don't crash if FIELDS is 0.

    * dbxout.c (dbxout_type): Don't crash if type only defines
    constructors and destructors.

    * cplus-typeck.c (build_component_ref): If METHOD_VEC is 0, break
    out of loop.

    * cplus-decl.c (finish_file): Don't abort if INIT is 0.

Thu Aug 17 21:55:35 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-parse.y (LC): If the type we get left of a '{'
    !IS_AGGR_TYPE, then make a fake node which can hold our types for
    us.

    * cplus-init.c (do_friend): Argument missing in call to
    grokclassfn.

    * cplus-decl.c (poplevel): Only call `expand_end_bindings' if the
    level being popped needed an `expand_start_bindings' to get going.
    This only happens if the level is specifically to hold
    temporaries (i.e., when the KEEP field is < 0).

    * cplus-decl.c (finish_decl): Emit a sorry message if the _DECL
    needs constructing, and is not at toplevel.

    * cplus-class.c (build_method_call): Complain about incomplete
    types only if (FLAGS&LOOKUP_COMPLAIN).

Wed Aug 16 17:11:22 1989  Michael Tiemann  (tiemann at yahi)

    * toplev.c (compile_file), cplus-lex.c (yylex): Use setjmp/longjmp
    to communicate fact that dump was just performed.  This prevents
    duplicate bytes being written to the asm file, due to inline
    functions being written out by both original and dumped compilers.

    * toplev.c (compile_file): Hack to make dumped compiler move bytes
    quickly from old asm file to new.

    * cplus-search.c (build_mi_virtuals,free_mi_matrix): Pointer
    arithmetic for mi_vmatrix accesses were off by 1.

    * cplus-class.c (build_method_call): Handle case where INSTANCE
    has a POINTER_TYPE type.  This is when it is a dummy argument for
    `operator new ()'.

Tue Aug 15 00:05:49 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (grokclassfn): `const' member function information
    was being lost.

    * cplus-class.c (build_method_call): Generate error message when
    passing const objects to non-const member functions.

    * cplus-class.c (finish_struct): METHOD_VEC must track the object
    being grown on the class obstack.

    * cplus-method.c (dump_type{_prefix}): Print `class' instead of
    `struct' if declared as class.

    * cplus-method.c (build_{decl,typename}_overload,do_actual_overload,
    fndecl_as_string): Distinguish `const' member functions from
    normal member functions.

    * cplus-search.c (get_base_type): Distinguish whether we want to
    know if a public field of baseclass is protected, or whether a
    conversion from derived to base class is protected by passing
    either 1 or 2 to the argument PROTECT.
    * cplus-search.c (get_base_distance): If protect is non-zero,
    always emit an error message if conversion from derived to base
    class is across a private visibility boundary.

    * cplus-cvt.c (convert_to_reference): Don't violate visibility
    rules when converting to references.  Add parameter PROTECT to
    control this behavior.  All callers changed.
    * cplus-cvt.c (build_up_reference): Ditto.

Mon Aug 14 00:03:46 1989  Michael Tiemann  (tiemann at yahi)

    * stmt.c (expand_end_case): Incorporate rfg's bugfix for
    optimizing case statements with signed negative test term.

    * cplus-search.c (reinit_search_statistics): New function.
    * toplev.c (compile_file): Call that function if BEEN_HERE_BEFORE.

    * cplus-decl.c: Remove explicit initializations from static
    variables--let them sit in common rather than data space.
    * cplus-method.c: Ditto.

    * Makefile,toplev.v, cplus-decl.c, cplus-lex.c: Incorporated
    changes from Bryan Boreham <kewill![e-mail]> to dump a
    running GNU C++ for later reexecing.
    * unexec.c,lastfile.c: borrowed from GNU Emacs
    * unex-addr.c,getpagesize.h: New files

    * Aug 14 13:07 g++.xtar.Z on ~ftp/pub

    * cplus-decl.c (finish_file): Handle case where initializer for
    one static aggregate is another.  Do so by disabling code which
    assumed the wrong thing in that case.

    * cplus-search.c, cplus-tree.c, cplus-class.c: Major surgery on
    assoc lists.  Virtual baseclasses are no longer represented in the
    main assoc list of a type.  CLASSTYPE_VBASECLASSES already holds
    such information.  Various functions changed and/or simplified to
    use value from that assoc list when needed.

    * cplus-decl.c (grokdeclarator): Don't get confused by
    non-storageclass bits in SPECBITS when DECL_CONTEXT == FIELD.

    * cplus-init.c (expand_aggr_init_1): Only check whether a new
    value has been assigned to `this' by the base class if
    FLAG_THIS_IS_VARIABLE is nonzero.

    * cplus-init.c (expand_aggr_init_1,build_new): Function
    `expand_aggr_vbase_init_1' was the wrong thing.  Change these
    functions to call `expand_aggr_vbase_init' instead.
    Also, #ifdef'd out `expand_aggr_vbase_init_1'.

    * cplus-search.c: Move assoc code from here...
    * cplus-tree.c: ...to here.

    * cplus-decl.c (lang_printable_name): Don't print return type for
    constructors or destructors.

    * cplus-class.c (finish_struct): Set TYPE_NEEDS_CONSTRUCTING bit
    if any default members.

    * cplus-decl.c (finish_file): Remove test for
    TYPE_NEEDS_CONSTRUCTING when considering vars in
    STATIC_AGGREGATES.  If something made it to this list, it should
    be initialized.

Sun Aug 13 14:25:55 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c: Rename static variable GLOBAL_AGGREGATES to
    STATIC_AGGREGATES.
    * cplus-decl.c (finish_decl): Put static aggregates on the
    STATIC_AGGREGATES list if the VAR_DECL is TREE_STATIC.  It does
    not have to be at the global_binding_level to get this treatment.
    Also, rename variable OLDGLOBAL to OLDSTATIC, and remove error
    messages which are no longer needed due to this change.

    * cplus-typeck.c (comptypes): Qualifiers must match.  (Fix taken
    from GCC).

    * cplus-init.c (expand_aggr_{vbase}_init,expand_recursive_init):
    provide arguments INPUT_FILENAME and LINENO to
    `expand_asm_operands'.
    * cplus-search.c (init_vbase_pointers,build_vbase_vtables_init):
    Ditto.

    * cplus-class.c (push_lang_context): Don't set current_lang_name
    if it is not a name we recognize.

    * All GNU C++ files: Merged changes from 1.35.95 to 1.35.96.

Sat Aug 12 00:27:43 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (finish_function): Call use_variable on
    CURRENT_VTABLE_DECL if it is non-NULL.

    * cplus-decl.c (finish_decl): Call build_indirect_ref instead of
    building the INDIRECT_REF by hand when setting the decl reference
    slot.

    * cplus-obstack.h: New file.  Defines obstack_int_grow and
    obstack_ptr_grow.  Cuts many calls to bcopy.
    * cplus-class.c: Use cplus-obstack.h instead of obstack.h.
    * cplus-search.c: Ditto.

    * cplus-parse.y (aggr): Fix minor nits in error messages.

    * cplus-class.c (finish_struct): Removed code which redundantly
    called `finish_decl' on static class members.

    * cplus-decl.c (finish_decl): C++ 2.0 now permits static class
    members to be of types with constructors.

    * cplus-search.c (bfs_unmark_finished_struct): Don't call
    assoc_value if TYPE == CURRENT_CLASS_TYPE.

    * cplus-search.c (assoc_value): Call compiler_error if we have
    multiple baseclass hits.  Also, make this function look for
    matches recursively.  This saves having to flatten out the
    hierarchy all the time, saving storage.

    * cplus-init.c (expand_recursive_init_1): Take into account fact
    that there is no virtual function table initialization needed if
    CLASSTYPE_NEEDS_VIRTUAL_REINIT set TREE_VALUE (init_list) to
    NULL_TREE.
    * cplus-class.c (build_class_init_list): Set up init lists
    correctly if the derived class just takes virtual function table
    initialization from the base class.

    * cplus-init.c (finish_base_init): Unmark fields initialized which
    belong to base classes.

    * cplus-decl.c (grokdeclarator,duplicate_decls): Implement C++ 2.0
    interpretation of `const'.

    * Aug 12 08:33 g++.xtar.Z on ~ftp/pub

    * cplus-typeck.c (commontype): Case for REFERENCE_TYPE appeared to
    be missing.
    * cplus-typeck.c (comptypes): Ditto.

    * cplus-typeck.c (comp_target_parms): Braino caused this function
    to return after processing just the first argument!

    * cplus-typeck.c (comp_target_parms,compparms): Take
    contravariance into account for argument lists.

Fri Aug 11 04:58:40 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-tree.c (list_hash): Implement hashing scheme for
    unchanging list nodes, such as compose TYPE_BASELINKS.
    Several new functions and data structures implement this.
    * cplus-search.c (get_baselinks): Call hash_tree_cons instead of
    tree_cons to get fresh nodes.

    * tree.c (init_tree): Remove call to bzero for hash_table.

    * cplus-init.c (expand_aggr_init): Typo in call to
    expand_vec_init.

    * newld.c (decode_command): Fix failure to bzero all entries in
    FILE_TABLE.

    * cplus-lex.c (cons_up_dtor_for_type): Add missing QUALS
    parameter in call to start_method.

    * cplus-decl.c (start_function): Set TREE_READONLY and
    TREE_VOLATILE bits of C_C_D.
    * cplus-class.c (popclass): Ditto.

    * cplus-tree.c (build_cplus_method_type): New function.  Like
    `build_method_type', but permits qualifiers for the instance
    variable.
    * cplus-tree.h: Declare it.
    * cplus-decl.c (grokdeclarator,grokclassfn): Call this function
    instead of build_method_type.

    * tree.c (build_method_type): Set TYPE_METHOD_BASETYPE from the
    TYPE_MAIN_VARIANT of BASETYPE.

    * cplus-lex.c (gplus.input): Change `friend' from TYPE_QUAL to
    SCSPEC.

    * cplus-parse.y (fn.def1): Permit const and volatile member
    functions.
    * cplus-method.c (stash_inline_prefix): Handle case of const and/or
    volatile member functions declared inside class.
    * cplus-decl.c (start_{method,function}): Grok const and volatile
    member functions.
    * cplus-decl.c (grokdeclarator): New parameter QUALS.

    * cplus-typeck.c (readonly_warning_or_error): If ARG is a
    PARM_DECL, print its name.  Also, if the message is due to the
    underlying structure of a COMPONENT_REF, tell user the
    member name instead of trying to hunt down the structure name.
    also, if ARG is a reference variable or parameter, name the
    reference as well.

    * cplus-cvt.c (build_up_reference): Handle case where we build a
    reference to a sub-object of an object which uses multiple
    inheritance.

    * cplus-class.c (finish_struct): Simplify conditions under which
    CLASSTYPE_NEEDS_VIRTUAL_REINIT is used, and use it.

Thu Aug 10 00:13:03 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-parse.y (member_init): If base class is virtual, save the
    intializer on the permanent_obstack.

    * cplus-init.c (expand_aggr_vbase_init_1): New function.  Called
    to actually walk the virtual baseclass initialization list.

    * cplus-init.c (expand_aggr_vbase_init): New argument DECL is
    the FUNCTION_DECL for the constructor by which this object is
    initialized.  From that constructor comes the virtual base class
    initialization list.

    * cplus-init.c (finish_base_init): Store initializers for virtual
    base classes.

    * cplus-tree.h (lang_decl): Add new field `vbase_init_list'.
    Holds initializers for virtual base classes.

    * cplus-init.c (build_new): Arrange to initialize virtual
    baseclasses before calling constructor if FLAG_THIS_IS_VARIABLE
    is zero.  Otherwise, constructor will call it on allocation.

    * cplus-cvt.c (convert_to_nonzero_pointer): If EXPR is already
    of type TYPE, don't build a NOP_EXPR; instead, just return
    EXPR.

    * cplus-class.c (build_method_call): If INSTANCE is NULL_TREE,
    then pre-allocate storage for the constructor.  After that, if
    there are virtual baseclasses to initialize, initialize them right
    away.  Then call constructor with resulting argument.

    * cplus-decl.c (flag_this_is_variable): Change default from 1 to 0.
    * cplus-decl.c (lang_decode_option): Recognize
    `-fthis-is-variable' on command line.
    * cplus-decl.c (finish_function): Don't emit test for whether `this'
    is zero if FLAG_THIS_IS_VARIABLE is zero.  Check both constructor
    and destructor case.
    * cplus-decl.c (grokclassfn): Make `this' a *const if
    !FLAG_THIS_IS_VARIABLE.

    * cplus-search.c (build_mi_matrix): Initialize MI_SIZE when
    reusing an old mi-matrix.

    * cplus-cvt.c (convert_to_nonzero_pointer): Abort if argument is
    integer_zerop.

    * cplus-class.c (build_method_call): Simplify code, mostly for
    speed.

    * cplus-search.c (lookup_field): Use my_tree_cons instead of
    tree_cons for looking up fields.

    * cplus-search.c (my_{tree_cons,build_string}): Use SET_TREE_CODE
    to set tree code.

    * cplus-decl.c (finish_decl): Initialize globals whose type needs
    constructing, but ! IS_AGGR_TYPE (type), with empty_init_node to
    keep assemble_variable from crashing.

    * cplus-search.c (build_mi_matrix): Take into account
    CLASSTYPE_N_VBASECLASSES when computing MI_SIZE.
    * cplus-class.c (finish_struct): Braino: set
    CLASSTYPE_N_VBASECLASSES after calling layout_vbasetypes.

    * cplus-class.c (finish_base_struct): Set MAX_HAS_VIRTUAL
    regardless of whether base class is a virtual baseclass or not.
    * cplus-class.c (finish_struct): Also, set MAX_HAS_VIRTUAL
    taking into account virtual baseclasses.
    * cplus-tree.c (layout_vbasetypes): Takes new arg PMAX which
    passes info of maximum number of virtual functions defined in
    virtual baseclasses from this function to finish_struct.

    * cplus-class.c (finish_struct): Set MAX_HAS_VIRTUAL if
    HAS_VIRTUAL is set.

    * cplus-class.c (modify_vtable_entry): If VFIELD can be
    NULL_TREE, if the current class has no virtual function except
    those inherited from a virtual baseclass.  In such a case,
    NORMAL will be zero.

    * cplus-lex.c (copy_type_lang_specific): Copy the array of
    basetypes so that CLASSTYPE_BASECLASS (t, i) gives the right
    baseclass.

Wed Aug  9 10:41:17 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-typeck.c (c_expand_return): Don't pass return value though
    a temporary if there are no pending cleanups.
    * stmt.c (no_pending_cleanups): New function to support above
    change.

    * stmt.c (assign_parms): Add test to see if we can avoid calling
    convert_units if possible.

    * cplus-decl.c (grokparms): Use variables LAST_RESULT and
    LAST_DECL to eliminate need to call `chainon'.

    * stmt.c (expand_fixup,expand_start_bindings): Use static variable
    EMPTY_CLEANUP_LIST to short-circuit cleanup checking, and also
    cut down on calls to tree_cons, in new binding contours, which are
    quite frequent in C++ (20% of calls to tree_cons, and 5% of total
    TREE_LIST nodes).

    * stmt.c (expand_start_*): Build new nesting level structure on
    obstack instead of calling malloc.  New variable STMT_OBSTACK.
    New function `init_stmt'.
    * toplev.c: Call `init_stmt'.

    * obstack.h (obstack_{ptr,int}_grow): New macros.

    * cplus-cvt.c (build_default_{binary,unary}_type_conversion):
    Handle case where one (or both) incoming types are "C" types, not
    "C++" types.

    * cplus-cvt.c (convert_to_pointer): If we go through any virtual
    base pointers, make sure that casts to BASETYPE from the last
    virtual base class use the right value for BASETYPE.

    * cplus-search.c (dfs_find_vbases): VBASES are now TREE_VECs,
    not TREE_LISTS.  Change variable named OFFSET_INFO to ASSOC,
    and use accordingly.

    * cplus-search.c (dfs_get_vbase_types): Make assocs in VBASE_TYPES
    contain the true basetype, not its MAIN_VARIANT.

Tue Aug  8 00:19:43 1989  Michael Tiemann  (tiemann at yahi)

    * stor-layout.c (layout_basetypes): Don't inherit assoc info.
    Synthesize it instead.

    * cplus-class.c (finish_struct): Reenable code which fills in
    virtual function tables of virtual baseclasses.

    * cplus-class.c (finish_struct): Fill in virtual function table
    with values which come from virtual or non-leftmost baseclasses.
    These are not filled in correctly by `modify_vtable_entry', which
    for these cases, only correctly allocates their skeleton.

    * cplus-class.c (modify_vtable_entry): Only call get_base_distance
    when BASE != CONTEXT.

    * cplus-search.c (get_base_distance): Don't push a search_stack
    level until we know we need it and will use it.

    * cplus-class.c (modify_vtable_entry): Once we know what vtable is
    of interest, set BASE to the best approximation of T's vtable we
    know.  I.e., set it to the vtable for the immediate super-class of
    T.

Mon Aug  7 17:12:31 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (finish_struct): When extending the bounds of the
    virtaul function table, keep VFIELDS as it was; don't move it up
    the inheritance tree.

    * cplus-class.c (finish_struct): No need to allocate a lang_decl
    for the virtual function table pointer FIELD_DECL.  Others need
    bits, but not bytes that FUNCTION_DECLs need.

    * cplus-init.c (build_virtual_init): For now, assume that FOR_TYPE
    and TYPE may be distinct, so use assoc lists to find the right
    vtable.

    * cplus-init.c (expand_recursive_init_1): Initialize the virtual
    function table of sub-components of aggregates driven by
    sub-component.  Otherwise, we have to initialize the virtual
    function table driven by the caller who knows what sub-components
    must be initialized.  Question: will this cause multiple
    initialization of vtables which are not down the left-hand side?
    Answer is probably yes.

    * tree.c (make_tree_vec): New function.

    * tree.c (copy_node): Now handles TREE_VEC correctly.

    * cplus-search.c ({make,copy}_assoc,assoc_value,debug_dump_assoc):
    Change representation of assoc list from TREE_LIST to TREE_VEC
    representation.
    * cplus-tree.h (ASSOC_* macros): Also here.

    * cplus-typeck.c (process_init_constructor): Don't complain about
    non-initialization of static class members, regardless of whether
    they are in global scope or not.  (Previously only complained when
    at global scope.)

    * cplus-class.c (finish_struct): Allocate method_vec if members
    need destructors.

Sun Aug  6 10:23:31 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (finish_struct): Eliminate redundant
    initialization of class fields to 0.

    * cplus-parse.y (parm rules): Use void_list_node instead of
    build_tree_list (NULL_TREE, void_type_node) where possible.

    * print-tree.c (dump): Handle TREE_VEC case.

    * cplus-init.c (add_method): Modified, and moved to cplus-class.c.

    * cplus-tree.h (lang_type): Change representation of list of
    member functions from list of lists to vector of lists.
    * cplus-class.c (finish_struct,build_method_call): Also here.
    * cplus-method.c (do_inline_function_hair): Also here.
    * cplus-decl.c (grokclassfn): Also here.
    * cplus-init.c (build_delete,build_member_ref): Also here
    * cplus-ptree.c (walk_lang_type): Also here.
    * cplus-search.c (lookup_fnfields{_1},get_baselinks,dfs_pushdecls,
    dfs_compress_decls,dfs_popdecls): Also here.
    * cplus-typeck.c (build_component_ref): Also here.
    * dbxout.c (dbxout_type): Also here.

    * cplus-class.c (build_method_call): Remove vestigal use of
    OVERLOAD_MAX_LEN.

Sat Aug  5 09:49:48 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (grokparms): Reuse TREE_LIST node in usual case of
    parameter processing.

    * cplus-decl.c (init_decl_processing): Do things here which used
    to be done in toplev.c
    * toplev.c (various places): Merge with GCC.

Fri Aug  4 17:47:24 1989  Michael Tiemann  (tiemann at yahi)

    * stor-layout.c (genop): Avoid creating new nodes when old ones
    will do.
    * stor-layout.c (build_int): Cache sizes we have made for types.

Thu Aug  3 21:44:04 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (pushdecl): Canonicalize enum typedefs same as
    struct, class, and unions.

    * cplus-init.c (resolve_member_ref): When member is of
    METHOD_TYPE, return logical address of the member, not the member
    itself.  The member itself has type METHOD_TYPE, which has mode
    EPmode, which is not a valid mode for expand_expr.

    * cplus-init.c (expand_vec_delete): When calling vector delete on
    store which does not need destructors, just ignore the argument,
    and delete the container (array) instead.

    * cplus-decl.c (start_function): Handle case where OLDDECL comes
    back as a TREE_LIST.

Wed Aug  2 10:54:54 1989  Michael Tiemann  (tiemann at yahi)

    * collect.c (process): Initialize ldptr to NULL if COFF is defined.

    * cplus-method.c (stash_inline_prefix): String name of function is
    IDENTIFIER_POINTER (DECL_NAME (...)), not DECL_NAME.

Mon Jul 31 12:14:35 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (finish_decl): Handle case where INIT can be a
    TREE_LIST when initializing a named return value.  Specifically,
    translate a TREE_LIST into a COMPOUND_EXPR when initializing a
    referece.

    * toplev.c (compile_file): Gripe about *non*-extern functions
    declared static but not defined.

    * cplus-init.c (build_delete): Keep ADDR parameter from being
    evaluated multiple times if TREE_VOLATILE.

    * cplus-decl.c (grok_function_init): Note whether DECL is an
    uninheritable virtual (i.e., a virtual function of an "abstract
    class").
    * cplus-tree.h (lang_decl): Add bit to record above info.
    * cplus-class.c (build_method_call): Give error if compiler can
    detect that user is attempting to call this function for an object
    whose type is that of the "abstract class".

    * gcc.c (link_spec): Make libg++.a available via %s rather than
    from -lg++.

Fri Jul 28 00:22:14 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-typeck.c (comp_target_types): Take contravariance into
    account for OFFSET_TYPE.

    * cplus-decl.c (grokdeclarator): When declaring an array, always
    call suspend momentary, since the TYPE_DOMAIN of the array may be
    needed later, for instance by expand_vec_delete.
    * cplus-parse.y (nonmomentary_expr): Second change needed to
    ensure that above condition is met.

    * cplus-decl.c (grokdeclarator): Handle case of derived class
    declaring member function static when derived class declared
    member function virtual.

    * cplus-decl.c (grokparms): Permit functions which have default
    arguments to end with `...'.
    cplus-typeck.c (actualparameterlist): Handle this new case.

    * cplus-typeck.c (c_expand_return): Handle case where conversion
    to return type of function returns ERROR_MARK_NODE.

    * cplus-init.c (build_delete): Handle case where member type is
    ARRAY_TYPE.

    * cplus-parse.y (component_decl): Handle case of missing ';'
    before '}'.

    * cplus-typeck.c (c_expand_start_case): Handle case where switch
    quantity is a MEMBER_REF.

    * cplus-method.c (build_component_type_expr): Handle case of
    calling non-virtual type conversion operators.

    * cplus-decl.c (shadow_tag): Make permanent any type created here.

    * gcc.c (struct compiler compilers[]): add -D__GNUC__ to files
    which are compiled using GNU C++.

    * cplus-parse.y (primary <- IDENTIFIER): If the identifier is a
    class-local enumeral value, check visibility--it may be a private
    member of a base class.

    * cplus-cvt.c (convert_force): New function.  Permit conversion from
    sub-type to private super-type.
    * cplus-typeck.c (build_c_cast): Call convert_force instead of
    convert.

    * cplus-typeck.c (build_x_function_call): Don't crash if asked to
    resolve a function which has been declared overloaded, but does
    not yet have any signatures.

    * cplus-class.c (finish_decl): Don't crash when warning (or
    flagging as error) that array types in static objects cannot need
    constructors.

Thu Jul 27 02:26:27 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-tree.c (build_cplus_array_type): Make array type permanent
    if ELT_TYPE is permanent.  This is needed because the array type
    may exist within an inline function, and that inline function may
    be expanded at any future time.

    * cplus-typeck.c (build_scoped_ref): Typo caused fn call to have
    virtually no effect.

    * cplus-init.c (expand_recursive_init): Make usage of global
    INIT_PTR reentrant.

    * cplus-search.c (dfs_pushdecls): Don't try initializing a
    TYPE_DECL, just continue through it.

    * integrate.c (access_parm_map): Don't compensate for
    BYTES_BIG_ENDIAN if parm is BLKmode.

    * stmt.c (various places): Make stmt.c agree much more closely
    with GCC's stmt.c.  Now only a few places where there are
    differences.  These have to do with calling do_pending_adjust
    before running cleanups, and using `lang_printable_name' instead
    of DECL_PRINT_NAME to assign to `current_function_name'.

Wed Jul 26 15:04:45 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-decl.c (finish_decl): If decl is static, but initialized
    by non-static initializer (such as an object initialized by a
    constructor), use a special initializer to make the decl lay down
    in data rather than bss space.
    * varasm.c (assemble_variable): Remove C++-specific code for above
    case.

Tue Jul 25 13:10:19 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (modify_vtable_entry): If the base fndecl is
    not contained in the vtable, don't try to modify the vtable.
    This automatically includes virtual functions from virtual base
    classes.
    * cplus-class.c (modify_vtable_entry): If the virtual function
    does come from a virtual base class, remember to change its
    DECL_VINDEX from a FUNCTION_DECL to an INTEGER_CST before
    continuing with the loop.  Use the DECL_VINDEX of the base
    FUNCTION_DECL.

    * cplus-search.c (debug_dump_assoc): New function.

Mon Jul 24 11:22:50 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (finish_struct): Break out code to initialize a
    struct with information deriving from its base classes.
    * cplus-class.c (finish_base_struct): New function where that code
    now lives.

    * cplus-search.c (dfs_get_vbase_types): Make full association
    list; Don't do so only when TREE_VIRTUAL bit is set.

Sun Jul 23 20:31:57 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (modify_vtable_entry): Braino caused base
    association to overwrite derived associate, causing base
    virtual functions to appear in derived virtual function tables
    when they shouldn't have.

Sat Jul 22 14:48:51 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-lex.c (yylex): Characters are of type `char'
    * cplus-decl.c (lang_decode_option): No longer a need for
    flag_char_charconst.
    * flags.h: ditto.

    * All GNU C++ files: Merged changes from 1.35 to 1.35.95.

Thu May 25 02:56:16 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-init.c (expand_aggr_init_1): make sure to emit error
      message when following an error path.

    * stor-layout.c (layout_decl): call this function instead of
      cplus_size_in_bytes.  This saves many calls to `convert_units'.

    * cplus-typeck.c (cplus_size): new function, just returns the size
      of the type we are interested in (no units conversion is done).

    * cplus-decl.c (init_decl_processing): preallocate
      IDENTIFIER_NODES for `this' and `__delete_me__'; saves calls to
      get_identifier.

    * cplus-parse.y, cplus-lex.c: tried to speed things up.  Removed
      vestigial `@' construct from cplus-parse.y.  Also parse '(' ')'
      as a single token.

    * cplus-init.c (add_friend): make sure to return void_type_node if
      we want our callers not to see anything.  Also, undo having set
      TREE_GETS_{NEW,DELETE} if the friend we get is global operator new or
      global operator delete.

Tue May 23 01:10:51 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-typeck.c (build_modify_expr): Recursive memberwise
      assignment must work on all type variants, not just the main
      variant.  Otherwise, we can't assign a const B& to a B&.

    * cplus-cvt.c (convert_to_pointer): convert to virtual baseclasses
      through virtual baseclass pointers.  Also, give error if
      converting up from a virtual baseclass type.

Mon May 22 22:03:24 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (finish_struct): remember to give dynamic classes
      a vfield even if they don't define virtual functions (-fSOS).

    * cplus-decl.c (init_decl_processing): fixed typo: TYPE_POINTER_TO
      does not build a pointer type, but build_pointer_type does.

    * cplus-decl.c, cplus-init.c: allow builtin functions to be
      declared friends.

    * cplus-class.c (ideal_candidate): if the best candidates require
      user-defined type conversions, don't reject as ambiguous the
      case where one candidate comes from one class, and the other
      candidates come from base classes of that class.

    * stor-layout.c (layout_type): after laying out a type, make sure
      that all type variants get the type's size.

Fri May 19 13:20:07 1989  Michael Tiemann  (tiemann at yahi)

    * cplus-class.c (popclass): don't kill out prev_class_type's decls
      if not at the global binding level.

    * cplus-decl.c: added new field `class_shadowed', which may some
      day be used to implement nested clases.

    * newld.c (various places): round up size to double word boundary
      if defined(sparc) || defined(sun).

    * tree.c (lvalue_p): A CALL_EXPR is an lvalue if the return type
      is an addressable type.

    * cplus-init.c (make_friend_class): fix typo in error message.

    * cplus-class.c (finish_struct): Don't give error message if class
      is does not define virtual functions which must be defined if
      that class has some of its own.

    * cplus-class.c (instantiate_type): handle case where user
      requests member function using object, i.e., `x.f'.  If f is
      virtual, return the function found in the virtual function table.

    * stor-layout.c (layout_basetypes): language dependent code
      removed, put in cplus-class.c

    * stmt.c (expand_goto_internal, expand_end_bindings,
      fixup_cleanups): if cleanups were called on leaving a binding
      contour, and EXIT_IGNORE_STACK is not defined, call
      do_pending_stack_adjust.

    * gcc.c: recognize ".cxx" as a C++ file name extension.

    * cplus-typeck.c (convert_for_initialization,
      convert_for_assignment): convert MEMBER_REFs, if possible, to
      members or component refs as appropriate.

    * cplus-typeck.c (build_member_ref): recognize member refs which
      are not associated with any object in particular (i.e., could
      be, but need not be `this').

    * cplus-search.c (get_vbase_types): orders the virtual base
      classes so that initialization and anti-initialization are
      performed in correct order.  A virtual baseclass is not
      destroyed until all parts of the object which could be using
      that virtual base class are destroyed.

    * cplus-parse.y: call build_vbase_delete if appropriate.

    * cplus-init.c (expand_delete): call build_vbase_delete if
      appropriate.  No longer deletes parts of objects via virtual
      base classes.

    * cplus-init.c: new function build_vbase_delete, performs
      destructors on objects with virtual base classes.  new function
      build_x_delete calls free-store deallocator on objects without
      running destructors.

    * cplus-decl.c (pushdecl, shadow_tag, and xref_tag): implement
      C-like behavior in "C" language scope vis a vis type
      declarations.

    * cplus-decl.c: define macros PUSH_BINDING_LEVEL and
      POP_BINDING_LEVEL.  Use these macros where appropriate.  Fixed
      bug in popping binding contours in the presence of syntax
      errors.

    * README, config.g++, make-links.g++: fixed minor glitches

Wed May 17 20:34:29 1989  Michael Tiemann  (tiemann at yahi)

    * stor-layout.c: move code which deletes an incomplete base type
      to cplus-class.c.

    * cplus-class.c (finish_struct): call `propagate_basetype_offsets'.

    * cplus-class.c: new function `propagate_basetype_offsets' gives
      correct offsets to base types which are not immediate base types
      in a multiple inheritance lattice.

Tue May 16 09:40:00 1989  Michael Tiemann  (tiemann at yahi)

    * Started using ChangeLog for version 1.35.0